Visual-Studio-Code
senso-concept-Mcs (Vscode)

HitpMcs-creation:: {2026-04-09} as FileMcs

overview of Vscode

description::
VS Code is a new type of tool that combines the simplicity of a code editor with what developers need for their core edit-build-debug cycle.
Code provides comprehensive editing and debugging support, an extensibility model, and lightweight integration with existing tools.
VS Code is updated monthly with new features and bug fixes.
[https://github.com/microsoft/vscode]

name::
* McsEngl.McsTchInf000041.last.html//dirTchInf//dirMcs!⇒Vscode,
* McsEngl.dirTchInf/McsTchInf000041.last.html!⇒Vscode,
* McsEngl.VSCode,
* McsEngl.Visual-Studio-Code!⇒Vscode,
* McsEngl.Vscode!=McsTchInf000041,
* McsEngl.Vscode!=Visual-Studio-Code,
* McsEngl.Visual-Studio-Code.lagJsel-pgm!⇒Vscode,
* McsEngl.lagJsel-pgm.Visual-Studio-Code!⇒Vscode,
* McsEngl.lagJsel'Visual-Studio-Code!⇒Vscode,

user-interface of Vscode

description::
× HitpMcs-creation: {2026-03-26},
·

name:::
* McsEngl.VscUsif!=Vscode'user-interface,
* McsEngl.Vscode'user-interface!⇒VscUsif,

editor of VscUsif

description::
× HitpMcs-creation: {2026-03-26},
· The main area to edit your files. You can open as many editors as you like side by side vertically and horizontally.

name:::
* McsEngl.VscUsif'editor,
* McsEngl.Vscode'editor,

activity-bar of VscUsif

description::
× HitpMcs-creation: {2026-03-26},
· on the left with icons: explorer, search, source-code, ...

name:::
* McsEngl.VscUsif'activity-bar,
* McsEngl.Vscode'activity-bar,

primary-side-bar of VscUsif

description::
× HitpMcs-creation: {2026-03-26},
· Contains different views like the Explorer to assist you while working on your project.

Views:
* Explorer view -
* Search - Provides global search and replace across your open folder.
* Source Control - VS Code includes Git source control by default.
* Run - VS Code's Run and Debug View displays variables, call stacks, and breakpoints.
* Extensions - Install and manage your extensions within VS Code.
* Custom views - Views contributed by extensions.

name:::
* McsEngl.VscUsif'primary-side-bar,
* McsEngl.Vscode'primary-side-bar,

secondary-side-bar of VscUsif

description::
× HitpMcs-creation: {2026-03-26},
· Opposite the Primary Side Bar. By default, contains the Chat view. Drag and drop views from the Primary Side Bar to the Secondary Side Bar to move them.

name:::
* McsEngl.VscUsif'secondary-side-bar,
* McsEngl.Vscode'secondary-side-bar,

status-bar of VscUsif

description::
× HitpMcs-creation: {2026-03-26},
· Information about the opened project and the files you edit.

name:::
* McsEngl.VscUsif'status-bar,
* McsEngl.Vscode'status-bar,

panel of VscUsif

description::
× HitpMcs-creation: {2026-03-26},
· An additional space for views below the editor region. By default, it contains output, debug information, errors and warnings, and an integrated terminal. The Panel can also be moved to the left or right for more vertical space.

name:::
* McsEngl.VscUsif'panel,
* McsEngl.Vscode'panel,

terminal of VscUsif

description::
× HitpMcs-creation: {2026-04-12},
"Visual Studio Code includes a fully featured integrated terminal. You can use it to run commands like echo, ls, and git, just like a standalone terminal. The terminal in VS Code also provides integration with the editor to support features such as links to workspace files and error detection.
The terminal can use various shells installed on your machine. A shell is a program that interprets and executes the commands by interacting with the operating system. Examples of shells include Bash, Zsh, and PowerShell."
[{2026-04-12 retrieved} https://code.visualstudio.com/docs/terminal/getting-started]

name::
* McsEngl.VscUsif'terminal,
* McsEngl.Vscode'terminal,

browser of VscUsif

description::
× HitpMcs-creation: {2026-04-14},
"The integrated browser enables you to open and interact with web pages directly inside VS Code. Use it to preview web applications, test authentication flows, and select page elements to add as context to your AI chat prompts."
[{2026-04-14 retrieved} https://code.visualstudio.com/docs/debugtest/integrated-browser]

name::
* McsEngl.VscCmd.Browser: Open Integrated Browser (palette),
* McsEngl.VscUsif'browser,
* McsEngl.Vscode'browser,

AI of Vscode

description::
× HitpMcs-creation: {2026-04-10},
· Visual Studio Code's built-in AI features are powered by GitHub Copilot and large language models (LLMs). These features span multiple surfaces, from inline suggestions as you type to autonomous agents that implement entire features.
[{2026-04-10 retrieved} https://code.visualstudio.com/docs/copilot/concepts/overview]

name::
* McsEngl.VscAi!=Vscode'AI,
* McsEngl.Vscode'AI!⇒VscAi,

safety of VscAi

description::
× HitpMcs-creation: {2026-04-11},
× https://code.visualstudio.com/docs/copilot/security,
"AI-generated output requires review. Visual Studio Code includes multiple mechanisms to keep you in control of what changes reach your codebase. This article explains the control mechanisms, AI limitations, and security considerations you should be aware of."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/trust-and-safety]

name::
* McsEngl.VscAi'safety,
* McsEngl.VscAi'security,
* McsEngl.Vscode'safety,

limitation of VscAi

description::
× HitpMcs-creation: {2026-04-11},
"Incorrect output. Models can generate code that looks correct but contains bugs, uses deprecated APIs, or doesn't handle edge cases. Always test AI-generated code, especially for logic that affects security, data integrity, or critical flows.
Prompt injection. Malicious content in files, tool outputs, or web pages can attempt to redirect the agent's behavior. This is why VS Code includes tool approval gates and trust boundaries. Learn more about AI security.
Treat AI-generated output as a first draft: useful as a starting point, but always requiring your review and judgment. For more on how models work, including nondeterminism, knowledge boundaries, and context limits, see Language models."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/trust-and-safety#_ai-limitations-to-watch-for]

name::
* McsEngl.VscAi'limitation,

Chat of VscAi

description::
× HitpMcs-creation: {2026-04-10},
· Chat in Visual Studio Code enables you to use natural language for AI-powered coding assistance.

"Chat: the primary interface for interacting with agents and having multi-turn conversations. Use chat to assign tasks, ask questions, explore ideas, or get explanations. Switch between Agent, Ask, Plan and custom agents depending on your goal.
The VS Code Chat experience (primarily powered by **GitHub Copilot**) has evolved from a simple sidebar into a multi-layered "AI Agent" system. As of early 2026, it is no longer just a window for questions; it is an active participant in your development workflow.
Here is a high-level overview of how Chat is structured and its key capabilities.
---
## 1. The Three Layers of Chat
VS Code provides three ways to interact with AI, depending on your "zone" of work:
* **Chat View (`Ctrl+Alt+I`):** The persistent sidebar for deep-dives, brainstorming, and multi-file tasks. It maintains a long-term session history and provides the most comprehensive tools.
* **Inline Chat (`Ctrl+I`):** A lightweight bar that appears directly inside your code editor or terminal. Use this for quick refactors, explaining a specific line, or fixing a bug without losing your place.
* **Quick Chat (`Ctrl+Shift+Alt+L`):** A dropdown (similar to the Command Palette) for "one-and-done" questions while you're focused on another task.
---
## 2. Core Capabilities & "Smart Actions"
Beyond just answering questions, the Chat system can execute actions directly on your workspace:
* **Code Explanation & Refactoring:** Use `/explain` or `/fix` to analyze selected code.
* **Test Generation:** Use `/tests` to scaffold unit tests for the current file.
* **Terminal Integration:** Chat understands your terminal errors. You can use it to explain a stack trace or generate the correct CLI command to fix a build error.
* **Commit & PR Assistance:** Chat can automatically generate meaningful Git commit messages and Pull Request summaries based on your changes.
---
## 3. Agents & "Autopilot" (New for 2026)
The biggest shift in 2026 is the introduction of **Autonomous Agents**.
* **Agent Sessions:** You can delegate a task (e.g., *"Migrate this API to use the new schema"*) and the agent will plan the changes, edit multiple files, and run tests to verify its work.
* **Autopilot Mode:** In preview, agents can now approve their own actions and retry on errors without manual intervention for every step.
* **Integrated Browser:** Agents can now open a "headless" browser inside VS Code to verify UI changes, check for layout issues, or take screenshots for you to review.
---
## 4. Context & Customization
Chat is only as good as what it "sees." You can guide it using:
* **Variable Mentions (`#`):** Use `#file`, `#folder`, or `#selection` to tell the AI exactly what code to look at.
* **Custom Instructions:** You can define a `.github/copilot-instructions.md` file to tell the AI about your team’s specific coding standards or library preferences.
* **Model Selection:** You can switch between different "brains" (like GPT-5, Claude 4.5, or specialized local models) directly from the chat interface.
---
## 5. Summary Table
| Feature | Best For... | Keyboard Shortcut |
| **Chat View** | Research, complex refactors, and agents | `Ctrl+Alt+I` |
| **Inline Chat** | Quick edits and line-by-line fixes | `Ctrl+I` |
| **Agent Mode** | Multi-file tasks and autonomous work | Inside Chat View |
| **Slash Commands** | Common tasks (`/fix`, `/explain`, `/tests`) | Type `/` in any chat |
| **Variables** | Providing specific context (`#file`, `#terminal`) | Type `#` in any chat |
---
⭢ **Tip:** If you’re ever confused about what a specific agent or tool is doing, look for the **"Thinking"** block in the chat response. You can expand it to see the model's step-by-step reasoning and which files it accessed."
[{2026-04-09 retrieved} https://gemini.google.com/app/bd06be8f60ddef1a]

name::
* McsEngl.VscChat!=Vscode'Chat,
* McsEngl.Vscode'Chat!⇒VscChat,
* McsEngl.VscCmd.View/Chat: Ctrl+Alt+I!⇒VscChat,
* McsEngl.VscCmd.Chat: Ctrl+Alt+I//View!⇒VscChat,
* McsEngl.VscCmd.Ctrl+Alt+I: Chat//View!⇒VscChat,
* McsEngl.VscCmds.Ctrl+Alt+I: Chat//View!⇒VscChat,

session of VscChat

description::
× HitpMcs-creation: {2026-04-11},
"When you start a new chat session, you begin a new conversation with the AI.
Each session has its own context window and can run with a different agent type and permission level. You can run multiple sessions in parallel, each focused on a different task or topic."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/chat/chat-sessions#_start-a-new-chat-session]

name::
* McsEngl.VscChat'session,

slash-command of VscChat

description::
× HitpMcs-creation: {2026-04-11},
· Slash commands are shortcuts to specific functionality within the chat. You can use them to quickly perform actions, like fixing issues, generating tests, or explaining code.
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/reference/copilot-vscode-features#_slash-commands]

name::
* McsEngl.VscChat'slash-command,

VscChat'/doc::
· Generate code documentation comments from editor inline chat.
* McsEngl.VscChat'/doc,

VscChat'/explain
· Explain a code block, file, or programming concept.
* McsEngl.VscChat'/explain,

VscChat'/fix
· Ask to fix a code block or resolve compiler or linting errors.
* McsEngl.VscChat'/fix,

VscChat'/tests
· Generate tests for all or only the selected methods and functions in the editor.
* McsEngl.VscChat'/tests,

VscChat'/setupTests
· Get help setting up a testing framework for your code. Get recommendation for a relevant testing framework, steps to set up and configure it, and suggestions for VS Code testing extensions.
* McsEngl.VscChat'/setupTests,

VscChat'/clear
· Start a new chat session in the Chat view.
* McsEngl.VscChat'/clear,

VscChat'/compact
· Compact the conversation context by summarizing it. Useful when a conversation grows too long for the model's context window.
* McsEngl.VscChat'/compact,

VscChat'/fork
· Fork the current chat session into a new independent session that inherits the full conversation history. Learn more about forking chat sessions.
* McsEngl.VscChat'/fork,

VscChat'/debug
· Show the Chat Debug view to inspect the chat logs for troubleshooting.
* McsEngl.VscChat'/debug,

VscChat'/troubleshoot
· Ask the AI to analyze the agent debug logs for the current chat session. Optionally, include #session to select and diagnose a previous chat session. For example, /troubleshoot how many tokens did I use? or /troubleshoot list all paths you tried to load customizations in #session. Requires github.copilot.chat.agentDebugLog.enabled.
* McsEngl.VscChat'/troubleshoot,

VscChat'/new
· Scaffold a new VS Code workspace or file. Use natural language to describe the type of project/file you need, and preview the scaffolded content before creating it.
* McsEngl.VscChat'/new,

VscChat'/newNotebook
· Scaffold a new Jupyter notebook based on your requirements. Use natural language to describe what the notebook should contain.
* McsEngl.VscChat'/newNotebook,

VscChat'/init
· Generate or update workspace instructions (copilot-instructions.md or AGENTS.md) based on your project structure and coding patterns.
* McsEngl.VscChat'/init,

VscChat'/plan
· Create a detailed implementation plan for a complex coding task. Research requirements, ask clarifying questions, and generate a structured plan with steps, verification, and decisions.
* McsEngl.VscChat'/plan,

VscChat'/search
· Generate a search query for the Search view. Use natural language to describe what you want to search for.
* McsEngl.VscChat'/search,

VscChat'/startDebugging
· Generate a launch.json debug configuration file and start a debugging session from the Chat view.
* McsEngl.VscChat'/startDebugging,

VscChat'/agents
· Configure your custom agents.
* McsEngl.VscChat'/agents,

VscChat'/hooks
· Configure your hooks.
* McsEngl.VscChat'/hooks,

VscChat'/instructions
· Configure your custom instructions.
* McsEngl.VscChat'/instructions,

VscChat'/prompts
· Configure your reusable prompt files.
* McsEngl.VscChat'/prompts,

VscChat'/skills
· Configure your agent skills.
* McsEngl.VscChat'/skills,

VscChat'/create-prompt
· Generate a prompt file with AI assistance in Agent mode.
* McsEngl.VscChat'/create-prompt,

VscChat'/create-instruction
· Generate an instructions file with AI assistance in Agent mode.
* McsEngl.VscChat'/create-instruction,

VscChat'/create-skill
· Generate an agent skill with AI assistance in Agent mode.
* McsEngl.VscChat'/create-skill,

VscChat'/create-agent
· Generate a custom agent with AI assistance in Agent mode.
* McsEngl.VscChat'/create-agent,

VscChat'/create-hook
· Generate a hook configuration with AI assistance in Agent mode.
* McsEngl.VscChat'/create-hook,

VscChat'/yolo/autoApprove
· Enable global auto-approval of all tool calls (chat.tools.global.autoApprove This setting is managed at the organization level. Contact your administrator to change it.ORG). Shows a warning dialog the first time.
* McsEngl.VscChat'/yolo,
* McsEngl.VscChat'/autoApprove,

VscChat'/disableYolo/disableAutoApprove
· Disable global auto-approval of all tool calls.
* McsEngl.VscChat'/disableYolo,
* McsEngl.VscChat'/disableAutoApprove,

VscChat'/<skill name>
· Run an agent skill in chat. For example, if you have a skill file named webapp-testing.md, you can run it by typing /webapp-testing.
* McsEngl.VscChat'/<skill name>, ,

VscChat'/<prompt name>
· Run a reusable prompt in chat.
* McsEngl.VscChat'/<prompt name>,

Chat-customizations-editor of VscChat

description::
× HitpMcs-creation: {2026-04-13},
"The Chat Customizations editor provides a centralized UI for creating and managing all your chat customizations in one place. The editor organizes the different customization types into separate tabs and provides an embedded code editor for editing customization files with syntax highlighting and validation.
You can create new customizations from scratch by editing the corresponding Markdown, or use AI to generate initial content based on your specific project.
To add MCP servers and agent plugins, you can browse the corresponding marketplace directly from the editor, install new items, and manage existing ones.
To open the Chat Customizations editor, select the Configure Chat (gear icon) in the Chat view or run Chat: Open Chat Customizations from the Command Palette (Ctrl+Shift+P).
You can configure customization for different agent types: local agents, Copilot CLI, and the Claude agent. Select the agent type from the dropdown at the top of the editor to view and manage customizations for that agent type."
[{2026-04-13 retrieved} https://code.visualstudio.com/docs/copilot/customization/overview#_chat-customizations-editor]

name::
* McsEngl.VscChat'chat-customizations-editor,
* McsEngl.Vscode'chat-customizations-editor,

GitHub-Copilot of VscAi

description::
× HitpMcs-creation: {2026-04-09},
× https://code.visualstudio.com/docs/copilot/getting-started,
× https://code.visualstudio.com/docs/copilot/setup,
· GitHub Copilot in Visual Studio Code provides autonomous agents, inline suggestions, chat, and smart actions.
[{2026-04-14 retrieved} https://code.visualstudio.com/docs/copilot/reference/copilot-vscode-features]

"GitHub Copilot brings AI agents to Visual Studio Code. Describe what you want to build, and an agent plans the approach, writes the code, and verifies the result across your entire project. Choose from Copilot's built-in agents, third-party agents from providers like Anthropic and OpenAI, or your own custom agents, and run them locally, in the background, or in the cloud. For more targeted changes, inline suggestions and chat give you precise control directly in the editor."
[{2026-04-09 retrieved} https://code.visualstudio.com/docs/copilot/overview]

"VS Code offers AI across a spectrum of interaction surfaces, each suited to different tasks:
* Agents: autonomous sessions that follow the full agent loop, reading files, executing coordinated changes across multiple files, running commands, and iterating until the task is complete. Agents handle multi-step tasks end-to-end, from implementing features to architecture-level refactoring and framework migrations.
* Chat: the primary interface for interacting with agents and having multi-turn conversations. Use chat to assign tasks, ask questions, explore ideas, or get explanations. Switch between Agent, Ask, Plan and custom agents depending on your goal.
* Inline chat: a lightweight chat interface that opens directly in the editor for quick, focused edits.
* Inline suggestions: code suggestions that appear as ghost text while you type. These use specialized completion models and don't involve an agent loop or tools. Next edit suggestions (NES) go further by predicting where your next edit should happen.
* Smart actions: one-click AI actions integrated into your workflow, like generating commit messages or fixing diagnostics errors.
[{2026-04-10 retrieved} https://code.visualstudio.com/docs/copilot/concepts/overview]

name::
* McsEngl.Vscode'GitHub-Copilot,

AiAgent of VscAi

description::
× HitpMcs-creation: {2026-03-25},
× generic: coding-AiAgent,
· An agent is an AI system that can plan and take actions to accomplish a task. In VS Code, agents use language models to reason about the best course of action, and tools to interact with the environment. With tools, agents can read files, make code changes, run terminal commands, and reach out to external services. The agent chains these actions together as needed until it accomplishes the task.

name:::
* McsEngl.VscAgent!=Vscode'AiAgent,
* McsEngl.Vscode'AiAgent!⇒VscAgent,

language-model of VscAgent

description::
× HitpMcs-creation: {2026-03-25},
"Visual Studio Code offers different built-in language models that are optimized for different tasks. You can also bring your own language model API key to use models from other providers."
[{2026-03-25 retrieved} https://code.visualstudio.com/docs/copilot/customization/language-models]

name:::
* McsEngl.VscAgent'language-model,

prompt of language-model

description::
× HitpMcs-creation: {2026-04-10},
· In VS Code, the prompt is assembled from multiple sources: your message, conversation history, file contents, tool outputs, and custom instructions.
[{2026-04-10 retrieved} https://code.visualstudio.com/docs/copilot/concepts/language-models]

· Ask: Explain the difference between async/await and promises.
· Agent: Fix the issues in #problems
· Agent: Explain the difference between async/await and promises.

name::
* McsEngl.VscAgent'prompt,
* McsEngl.VscAi'prompt,

tool of VscAgent

description::
× HitpMcs-creation: {2026-03-25},
· Tools are the mechanism that lets the model act on your development environment. Without tools, a language model can only generate text. With tools, an agent can read files, write code, run terminal commands, search your codebase, and connect to external services.
During the agent loop, the model decides which tools to call based on the task. Each tool call produces output that becomes part of the context for the next iteration.
[{2026-04-10 retrieved} https://code.visualstudio.com/docs/copilot/concepts/tools]
· Use the Configure Tools button in the chat input field to enable or disable individual tools for the current request.

name:::
* McsEngl.VscAgent'tool!⇒VscTool,
* McsEngl.Vscode'tool!⇒VscTool,
* McsEngl.VscTool!=Vscode'tool,

tool.SPECIFIC

description::
× HitpMcs-creation: {2026-04-10},
· VS Code supports three types of tools:
* Built-in tools: tools that ship with VS Code for common development tasks, like reading and writing files, running terminal commands, searching your codebase, and navigating the editor. These are available immediately without any setup.
* MCP tools: tools provided by Model Context Protocol (MCP) servers, an open standard for connecting AI models to external tools and data sources. MCP servers can run locally on your machine or be hosted remotely. Use MCP tools to connect to databases, APIs, and other external services.
* Extension tools: tools contributed by VS Code extensions through the Language Model Tools API. Extension tools integrate deeply with the editor and are available when you install the extension.

context of VscAgent

description::
× HitpMcs-creation: {2026-03-25},
"The context window is the total amount of information a model can process in a single request. It includes everything: the system prompt, custom instructions, conversation history, file contents, tool outputs, and your current message. Different models have different context window sizes.
When the context window fills up, VS Code automatically summarizes older parts of the conversation to make room. This means important details from early in a long conversation might be compressed or lost. You can also type /compact in the chat input to manually trigger compaction at any time. Optionally, add custom instructions after the command to guide the summary, for example /compact focus on the API design decisions."
[{2026-03-25 retrieved} https://code.visualstudio.com/docs/copilot/concepts/language-models]

name:::
* McsEngl.VscAgent'context,

reasoning of VscAgent

description::
× HitpMcs-creation: {2026-03-25},
"Some language models can perform extended reasoning, also called "thinking", before producing a response. Instead of generating an answer immediately, a reasoning model first works through the problem internally, considering multiple approaches, evaluating trade-offs, and building a step-by-step chain of thought. This internal reasoning happens in dedicated thinking tokens that are separate from the final output.
Reasoning models are especially effective for complex tasks like multi-step debugging, architectural planning, code refactoring, and mathematical or scientific analysis. For simpler tasks like generating boilerplate or answering basic questions, the extra reasoning adds latency without significant benefit."
[{2026-03-25 retrieved} https://code.visualstudio.com/docs/copilot/concepts/language-models]

name:::
* McsEngl.VscAgent'reasoning,
* McsEngl.VscAgent'thinking,

loop of VscAgent

description::
× HitpMcs-creation: {2026-04-08},
"When you give an agent a task, it follows an agentic loop. This pattern is common across modern AI assistants. Within VS Code, an agent is the system that plans and takes actions, and the language model generates responses that inform those actions.

At each step, the agent evaluates its progress and picks the next action. It might open a file to understand an API, make an edit, then run a command to verify the change worked. The output of each action becomes input for the next decision.
Diagram showing the agentic loop: User prompt -> Agent reasoning -> Tool calls (read files, edit code, run tests) -> Agent updates based on tool results -> Final output for user review

The agent loop typically involves three high-level stages:
Understand. The agent reads files, searches the codebase, and looks up documentation to understand what needs to change.
Act. The agent modifies code, runs terminal commands, installs dependencies, or calls external services through tools.
Validate. The agent runs tests, checks for compiler errors, and reviews its own changes. If something is wrong, it continues iterating.
The agent uses the language model to reason about the best course of action. However, without the ability to interact with the environment, the model is limited to providing generic responses. With tools, the agent issues tool calls at each step to gather information and take actions like reading files, making code changes, running terminal commands, and reaching out to external services.

The agent chains these actions together as needed until it accomplishes the task. Answering a question about your codebase might involve only a few file reads. Implementing a new feature typically loops through editing, running tests, diagnosing failures, and editing again until the tests pass.

Behind the scenes, VS Code assembles the current context into a prompt and sends it to the language model. The model responds with text, a code edit, or a tool request. When a tool runs, its output is added to the context for the next iteration, and this cycle repeats until the task is complete.

You stay in control throughout the process. Send a new message to redirect the agent, add context, or suggest a different approach."
[{2026-04-08 retrieved} https://code.visualstudio.com/docs/copilot/concepts/agents]

name::
* McsEngl.VscAgent'loop,

plugin of VscAgent

description::
× HitpMcs-creation: {2026-04-11},
'Agent plugins are pre-packaged bundles of customizations you discover and install from plugin marketplaces. Instead of building everything yourself, you can install a plugin that provides a ready-made combination of slash commands, skills, custom agents, hooks, and MCP servers. Plugins are useful for adopting community best practices or sharing internal tooling across teams.'
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/customization#_agent-plugins]

name::
* McsEngl.VscAgent'plugin,

info-resource of VscAgent

description::
× HitpMcs-creation: {2026-04-08},
* https://code.visualstudio.com/docs/copilot/agents/overview,

name::
* McsEngl.VscAgent'info-resource,

VscAgent.SPECIFIC

description::
× HitpMcs-creation: {2026-04-08},
===
* local,
* cloud,
===
* autonomous,
* interactive,

name::
* McsEngl.VscAgent.specific,

VscAgent.builtin

description::
× HitpMcs-creation: {2026-04-11},
· VS Code has three built-in agents:
* Agent: autonomously plans and implements changes across files, runs terminal commands, and invokes tools.
* Plan: creates a structured, step-by-step implementation plan before writing any code. Hands the plan off to an implementation agent when it looks right.
* Ask: answers questions about coding concepts, your codebase, or VS Code itself without making file changes.
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/agents/overview]

name::
* McsEngl.VscAgent.builtin,

VscAgent.ask

description::
× HitpMcs-creation: {2026-04-11},
"The Ask feature works best for answering questions about your codebase, coding, and general technology concepts. Use Ask when you want to understand how something works, explore ideas, or get help with coding tasks.
Ask uses agentic capabilities to research your codebase and gather relevant context. Responses can contain code blocks that you apply individually to your codebase. To apply a code block, hover over the code block and select the Apply in Editor button."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/agents/local-agents#_ask]

name::
* McsEngl.VscAgent.ask,

VscAgent.plan

description::
× HitpMcs-creation: {2026-04-11},
"For complex tasks, jumping straight into code generation can lead to incomplete implementations or wrong architectural decisions. The built-in Plan agent collaborates with you to research the task and create a detailed implementation plan before any code changes are made. This ensures requirements are understood, edge cases are identified, and you agree on the approach before the agent starts writing code.
The plan agent uses a 4-phase iterative workflow:
* Discovery: research the task using read-only tools and codebase analysis.
* Alignment: ask clarifying questions to resolve ambiguities.
* Design: draft a structured implementation plan.
* Refinement: iterate on the plan based on your feedback.
The Plan agent does not make code changes until the plan is reviewed and approved. Once approved, you can hand off the plan to the default agent or save it for further refinement."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/agents#_planning]

name::
* McsEngl.VscAgent.plan,

VscAgent.local

description::
× HitpMcs-creation: {2026-04-11},
·

name::
* McsEngl.VscAgent.local,

VscAgent.cloud

description::
× HitpMcs-creation: {2026-04-11},
· Cloud agents run on remote infrastructure and integrate with GitHub repositories for team collaboration through pull requests. For example, the GitHub Copilot coding agent runs on GitHub's infrastructure and can implement features, address code review feedback, and open pull requests autonomously.
· Because cloud agents run remotely without user interaction, they are well-suited for tasks that have a well-defined scope and all necessary context. Their integration with pull requests makes them very effective for team collaboration.
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/agents/cloud-agents]

name::
* McsEngl.VscAgent.cloud,

VscAgent.third-party

description::
× HitpMcs-creation: {2026-04-11},
· Third-party agents in Visual Studio Code are AI agents developed by external providers, such as Anthropic and OpenAI. Third-party agents enable you to use the unique capabilities of these AI providers, while still benefiting from the unified agent sessions management in VS Code and the rich editor experience for coding, debugging, testing, and more. In addition, you can use these providers with your existing GitHub Copilot subscription.
VS Code uses the provider's SDK and agent harness to access the agent's unique capabilities. You can use both local and cloud-based third-party agents in VS Code. Integration with cloud-based third-party agents is enabled through your GitHub Copilot plan.
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/agents/third-party-agents]

name::
* McsEngl.VscAgent.third-party,

VscAgent.custom

description::
× HitpMcs-creation: {2026-04-09},
· Use custom agents when you need a persistent persona with its own tool restrictions and handoffs.

name::
* McsEngl.VscAgent.custom,

VscAgent.copilot-CLI

description::
× HitpMcs-creation: {2026-04-11},
· Copilot CLI: use the Copilot CLI to run in the background on your machine, optionally using Git worktrees for isolation.
· Copilot SDK sessions run outside of VS Code and continue to run in the background when you close your VS Code window.

name::
* McsEngl.VscAgent.copilot-CLI,

VscAgent.subagent

description::
× HitpMcs-creation: {2026-04-11},
"When working on complex tasks, the main agent can delegate subtasks to subagents. A subagent is an independent AI agent that performs focused work, such as researching a topic or analyzing code, and reports the results back to the main agent.
The primary benefit of subagents is context optimization. Without subagents, every file read, search result, and intermediate step during research accumulates in the main agent's context window, potentially crowding out important information. Subagents perform their work in a separate context window and return only a summary, keeping the main conversation focused on the task at hand."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/agents#_subagents]

name::
* McsEngl.VscAgent.subagent,

inline-chat of VscAi

description::
× HitpMcs-creation: {2026-04-10},
× https://code.visualstudio.com/docs/copilot/chat/inline-chat,
· Inline chat: a lightweight chat interface that opens directly in the editor for quick, focused edits.

* McsEngl.VscCmd.open-inline-chat: ctrl+I,
* McsEngl.VscCmd.ctrl+I: open-inline-chat,
* McsEngl.VscCmds.ctrl+I: open-inline-chat,

name::
* McsEngl.Vscode'inline-chat,

inline-suggestion of VscAi

description::
× HitpMcs-creation: {2026-04-10},
× https://code.visualstudio.com/docs/copilot/ai-powered-suggestions,
"GitHub Copilot in VS Code provides AI-powered inline suggestions that complete your code, comments, tests, and more as you type. Inline suggestions work with a broad range of programming languages and frameworks. They are one of several AI surfaces in VS Code, alongside agents for autonomous multi-file tasks, chat, and smart actions."
[{2026-04-14 retrieved} https://code.visualstudio.com/docs/copilot/ai-powered-suggestions]
· Inline suggestions: code suggestions that appear as ghost text while you type. These use specialized completion models and don't involve an agent loop or tools. Next edit suggestions (NES) go further by predicting where your next edit should happen.

name::
* McsEngl.VscAi'inline-suggestion!⇒VscInsg,
* McsEngl.VscInsg!=VscAi'inline-suggestion,
* McsEngl.Vscode'inline-suggestion!⇒VscInsg,

generation of VscInsg

description::
× HitpMcs-creation: {2026-04-14},
· Instead of relying on Copilot to provide suggestions, you can provide hints about what code you expect by using code-comments.
[{2026-04-14 retrieved} https://code.visualstudio.com/docs/copilot/ai-powered-suggestions#_generate-suggestions-from-code-comments]

name::
* McsEngl.VscInsg'generation,

VscInsg.next-edit-suggestion

description::
× HitpMcs-creation: {2026-04-14},
· An arrow in the gutter indicates if there is an edit suggestion available. The arrow indicates where the next edit suggestion is located, relative to your current cursor position.
· To get started with Copilot NES, enable the VS Code setting github.copilot.nextEditSuggestions.enabled
[{2026-04-14 retrieved} https://code.visualstudio.com/docs/copilot/ai-powered-suggestions#_next-edit-suggestions]

name::
* McsEngl.VscInsg.Copilot-NES,
* McsEngl.VscInsg.next-edit-suggestion,

smart-action of VscAi

description::
× HitpMcs-creation: {2026-04-10},
× https://code.visualstudio.com/docs/copilot/copilot-smart-actions,
· Smart actions: one-click AI actions integrated into your workflow, like generating commit messages or fixing diagnostics errors.

name::
* McsEngl.Vscode'smart-action,

AiCustomization of VscAi

description::
× HitpMcs-creation: {2026-04-09},
× https://code.visualstudio.com/docs/copilot/guides/customize-copilot-guide,
·
* AiAgent,
* agent-skill,
* agent-plugin,
* custom-agent,
* custom-instructions,
* hook,
* model-context-protocol-server,
* prompt-file,

name::
* McsEngl.VscAi'customization,
* McsEngl.Vscode'AiCustomization,

custom-instructions of VscAi

description::
× HitpMcs-creation: {2026-04-09},
× https://code.visualstudio.com/docs/copilot/customization/custom-instructions,
"Custom instructions enable you to define common guidelines and rules that automatically influence how AI generates code and handles other development tasks. Instead of manually including context in every chat prompt, specify custom instructions in a Markdown file to ensure consistent AI responses that align with your coding practices and project requirements.
You can configure custom instructions to apply automatically to all chat requests or to specific files only. Alternatively, you can manually attach custom instructions to a specific chat prompt."
[{2026-04-09 retrieved} https://code.visualstudio.com/docs/copilot/customization/custom-instructions]

name::
* McsEngl.VscAi'custom-instructions!=VscAiCstmInsn,
* McsEngl.VscAiCstmInsn!=Vscode-AI-custom-instructions,
* McsEngl.Vscode'custom-instructions!=VscAiCstmInsn,

VscAiCstmInsn.SPECIFIC

description::
× HitpMcs-creation: {2026-04-11},
There are two types:
* Always-on instructions: project-wide rules defined in .github/copilot-instructions.md that apply to every request. Use these for conventions the whole team follows, like code style, naming patterns, or preferred libraries.
* File-based instructions: guidelines in .instructions.md files that apply based on file path patterns or task descriptions. Use these when different parts of your codebase need different rules, such as React patterns for .tsx files or API conventions for your backend.
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/customization#_custom-instructions]

name::
* McsEngl.VscAiCstmInsn.specific,

VscAiCstmInsn.copilot-instructions.md

description::
× HitpMcs-creation: {2026-04-09},
· VS Code automatically detects a .github/copilot-instructions.md Markdown file in the root of your workspace and applies the instructions in this file to all chat requests within this workspace.
Use copilot-instructions.md for:
* Coding style and naming conventions that apply across the project
* Technology stack declarations and preferred libraries
* Architectural patterns to follow or avoid
* Security requirements and error handling approaches
* Documentation standards
[{2026-04-09 retrieved} https://code.visualstudio.com/docs/copilot/customization/custom-instructions]

name::
* McsEngl.VscAiCstmInsn'copilot-instructions.md,
* McsEngl.Vscode'copilot-instructions.md,

prompt-file of VscAi

description::
× HitpMcs-creation: {2026-04-09},
· Prompt files are Markdown files with the .prompt.md extension.
· Use prompt files for lightweight, single-task prompts.
[{2026-04-09 retrieved} https://code.visualstudio.com/docs/copilot/customization/prompt-files]

name::
* McsEngl.VscAi'prompt-file,
* McsEngl.VscPrompt!=prompt-file of Vscode,
* McsEngl.Vscode'prompt-file!⇒VscPrompt,
* McsEngl.Vscode'slash-command!⇒VscPrompt,

agent-skills of VscAi

description::
× HitpMcs-creation: {2026-04-11},
"Agent skills package multi-step capabilities as folders containing instructions, scripts, and resources. Unlike prompt files, which provide a single prompt, skills give the AI a complete toolkit for a domain-specific task such as generating API documentation, running security audits, or performing database migrations.
Skills load on demand when the task matches their description. They are built on an open standard, so the same skill works across different agent types."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/customization#_agent-skills]

name::
* McsEngl.VscAi'agent-skills,
* McsEngl.Vscode'agent-skills,

Model-Context-Protocol-MCP of VscAi

description::
× HitpMcs-creation: {2026-04-11},
× https://code.visualstudio.com/docs/copilot/customization/mcp-servers,
× https://code.visualstudio.com/api/extension-guides/ai/mcp,
"Model Context Protocol (MCP) is an open standard for connecting the AI to external tools and data sources. Without MCP, the AI can only work with code and the terminal. MCP servers extend its reach by providing tools that query databases, call APIs, interact with cloud services, or access any other external system.
MCP servers run locally or remotely and can also provide resources, prompts, and interactive apps."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/customization#_mcp]

name::
* McsEngl.MCP!=Model-Context-Protocol--of-Vscode,
* McsEngl.Model-Context-Protocol--of-Vscode,
* McsEngl.VscAi'MCP!=Model-Context-Protocol,
* McsEngl.Vscode'MCP!=Model-Context-Protocol,
* McsEngl.Vscode'Model-Context-Protocol,

hooks of VscAi

description::
× HitpMcs-creation: {2026-04-11},
× https://code.visualstudio.com/docs/copilot/customization/hooks,
"Hooks run custom shell commands at specific points during an agent session. While instructions and prompts guide what the AI does, hooks guarantee that your code runs at defined lifecycle points. This makes hooks the right choice when you need deterministic outcomes, such as running a formatter after every file edit, blocking commits that fail a lint check, or logging every tool invocation for an audit trail."
[{2026-04-11 retrieved} https://code.visualstudio.com/docs/copilot/concepts/customization#_hooks]

name::
* McsEngl.VscAi'hooks,
* McsEngl.Vscode'hooks,

agent-plugin of VscAi

description::
× HitpMcs-creation: {2026-04-14},
"Agent plugins are prepackaged bundles of chat customizations that you can discover and install from plugin marketplaces in Visual Studio Code. A single plugin can provide any combination of slash commands, agent skills, custom agents, hooks, and MCP servers."
[{2026-04-14 retrieved} https://code.visualstudio.com/docs/copilot/customization/agent-plugins]

name::
* McsEngl.VscAi'agent-plugin,
* McsEngl.Vscode'agent-plugin,
* McsEngl.Vscode'plugin,

settings of VscAi

description::
× HitpMcs-creation: {2026-04-14},
× https://code.visualstudio.com/docs/copilot/reference/copilot-settings,
· You can disable the built-in AI features in VS Code with the chat.disableAIFeatures setting, similar to how you configure other features in VS Code.
[{2026-04-14 retrieved} https://code.visualstudio.com/docs/copilot/setup#_remove-ai-features-from-vs-code]

name::
* McsEngl.VscAi'settings,
* McsEngl.Vscode'AI-settings,

extension of Vscode

description::
× HitpMcs-creation: {2025-12-11},
"### Overview of VS Code Extensions
Visual Studio Code (VS Code) is a highly extensible code editor developed by Microsoft. Its **extensions** are one of its biggest strengths, allowing users to add support for new programming languages, debuggers, tools, themes, snippets, and more. Extensions plug directly into VS Code's UI and APIs, enabling customization for virtually any development workflow.
#### Key Features of Extensions
- **Extensibility**: Add languages (e.g., Python, Go), linters, formatters, AI assistants, Git tools, and UI enhancements.
- **Marketplace**: The official source is the [Visual Studio Code Marketplace](https://marketplace.visualstudio.com/vscode), with tens of thousands of free and paid extensions. Many are open-source.
- **Installation and Management**:
- Open the Extensions view (Ctrl+Shift+X or Cmd+Shift+X on macOS).
- Search, install, update, disable, or uninstall directly in VS Code.
- Built-in extensions (e.g., for JavaScript/TypeScript) come pre-installed.
- Security: Extensions from third-party publishers require trust confirmation. VS Code scans for malware.
- **Categories**: Include themes, language packs, linters/formatters, debuggers, AI tools, Git integrations, and productivity boosters.
- **Syncing**: With Settings Sync or Profiles, extensions can be shared across devices.
Extensions run in a separate process for stability and performance.
#### Popular VS Code Extensions in 2025
Here are some of the most widely recommended and highly installed extensions (based on recent developer surveys and articles). These span productivity, code quality, AI, and Git:
1. **GitHub Copilot** (Microsoft) – AI-powered code suggestions and completions. A game-changer for faster coding (paid, with free trial).
2. **Prettier - Code Formatter** – Automatic code formatting for consistent style across teams (supports JS, TS, HTML, CSS, etc.).
3. **ESLint** – Linting for JavaScript/TypeScript to catch errors and enforce standards.
4. **GitLens** – Supercharges Git with blame annotations, history visualization, and repository insights.
5. **Live Server** – Launches a local development server with live reload for web projects.
6. **Python** (Microsoft) – Full support for Python (IntelliSense, debugging, linting).
7. **IntelliCode** (Microsoft) – AI-assisted IntelliSense for context-aware completions.
8. **ES7+ React/Redux/React-Native Snippets** – Quick snippets for React development.
9. **Material Icon Theme** or **vscode-icons** – Enhances file/folder icons for better navigation.
10. **Auto Rename Tag** – Automatically renames paired HTML/XML tags.
11. **Bracket Pair Colorizer** (or built-in successor) – Colors matching brackets for readability.
12. **Path Intellisense** – Autocompletes filenames in imports/paths.
13. **Code Spell Checker** – Catches spelling errors in comments and strings.
14. **Thunder Client** – Lightweight API testing (alternative to Postman).
15. **Docker** (Microsoft) – Manage containers, images, and Compose directly in VS Code.
AI tools like Copilot dominate in 2025, with growing focus on security scanners (e.g., for IaC) and specialized extensions for frameworks like React or Kubernetes.
To get started, open the Extensions view and search for these by name. Many have millions of installs and high ratings. If you're new, start with Prettier, ESLint, and GitLens for immediate productivity gains!"
[{2025-12-11 retrieved} https://x.com/i/grok?conversation=1999022421228106144]

name:::
* McsEngl.VscExtn!=Vscode'extension,
* McsEngl.Vscode'extension!⇒VscExtn,
* McsEngl.VscCmd.View/Extensions: Ctrl+Shift+X!⇒VscExtn,
* McsEngl.VscCmd.Extensions: Ctrl+Shift+X//View!⇒VscExtn,
* McsEngl.VscCmd.Ctrl+Shift+X: Extensions//View!⇒VscExtn,
* McsEngl.VscCmds.Ctrl+Shift+X: Extensions//View!⇒VscExtn,
* McsEngl.VscCmd.File/Preferences/Extensions: Ctrl+Shift+X!⇒VscExtn,
* McsEngl.VscCmd.Extensions: Ctrl+Shift+X//Preferences//File!⇒VscExtn,

MarketPlace of VscExtn

description::
× HitpMcs-creation: {2026-03-27},
× https://marketplace.visualstudio.com/vscode
· The Visual Studio Marketplace hosts thousands of extensions across a wide range of categories. To protect you from malicious extensions, it employs several mechanisms, like publisher trust, malware scanning, and more. Learn more about extension runtime security.
[{2026-03-27 retrieved} https://code.visualstudio.com/docs/getstarted/extensions]

name:::
* McsEngl.VscExtn'MarketPlace,
* McsEngl.Vscode'MarketPlace,

creating of VscExtn

description::
× HitpMcs-creation: {2026-03-30},
"## Option 2: Create a Simple Extension
Create a more powerful command that works exactly like your jEdit macro:
1. Create a new folder and open it in VS Code
2. Create `package.json`: 

json
    {
      "name": "insert-date",
      "displayName": "Insert Date",
      "description": "Insert Date as {2026-04-03}",
      "version": "0.0.1",
      "date": "{2026-04-03}"
      "publisher": "local",
      "engines": {
        "vscode": "^1.74.0"
      },
      "activationEvents": [],
      "main": "./extension.js",
      "contributes": {
        "commands": [
          {
            "command": "extension.insertDate",
            "title": "Insert Date in Braces"
          }
        ],
        "keybindings": [
          {
            "command": "extension.insertDate",
            "key": "ctrl+shift+d",
            "mac": "cmd+shift+d"
          }
        ]
      }
    }


3. Create `extension.js`: 
javascript
    const vscode = require('vscode');

    function activate(context) {
      let disposable = vscode.commands.registerCommand('insert-date.insertDate', () => {
        const editor = vscode.window.activeTextEditor;
        if (!editor) return;

        const now = new Date();
        const year = now.getFullYear();
        const month = now.getMonth() + 1;
        const day = now.getDate();

        // Format with leading zeros
        const formattedMonth = month < 10 ? '0' + month : '' + month;
        const formattedDay = day < 10 ? '0' + day : '' + day;

        const dateString = `{${year}-${formattedMonth}-${formattedDay} }`;

        editor.edit(editBuilder => {
          editBuilder.replace(editor.selection, dateString);
        });
      });

      context.subscriptions.push(disposable);
    }

    function deactivate() {}

    module.exports = {
      activate,
      deactivate
    };


4. Install dependencies:
bash
npm install --save-dev @types/vscode

5. Press F5 to test the extension
6. Use `Ctrl+Shift+D` (or `Cmd+Shift+D` on Mac) to insert the date"
==== install locally:
7.
npm install
npm install -g @vscode/vsce
vsce package //create .vsix file
8.
in VSCode-palette: Extensions: Install from VSIX
find .vsix file

name:::
* McsEngl.VscExtn'creating,

VscExtn.Keyboard-Macro-Beta

description::
× HitpMcs-creation: {2026-04-01},
× https://marketplace.visualstudio.com/items?itemName=tshino.kb-macro
· With this Visual Studio Code extension, you can record and playback your keyboard inputs.

name:::
* McsEngl.Keyboard-Macro-Beta--VscExtn,
* McsEngl.VscExtn.Keyboard-Macro-Beta,

VscExtn.Unicode-Code-Point

description::
× HitpMcs-creation: {2026-03-29},
× publisher: Josip Medved,
· Displays character's unicode code point in status bar.

name:::
* McsEngl.VscExtn.Unicode-Code-Point,

command of Vscode

description::
× HitpMcs-creation: {2026-03-25},
× https://code.visualstudio.com/api/extension-guides/command
× https://code.visualstudio.com/api/references/commands

* File
* Edit
* Selection
* View
* Go
* Run
* Terminal
* Help

name:::
* McsEngl.VscCmd!=Vscode'command,
* McsEngl.VscCmnd!⇒VscCmd,
* McsEngl.Vscode'command!⇒VscCmd,

shortcut of VscCmd

description::
× HitpMcs-creation: {2026-03-25},
"General
Ctrl+Shift+P, F1 Show Command Palette
Ctrl+P Quick Open, Go to File…
Ctrl+Shift+N New window/instance
Ctrl+Shift+W Close window/instance
Ctrl+, User Settings
Ctrl+K Ctrl+S Keyboard Shortcuts
---
Basic editing
Ctrl+X Cut line (empty selection)
Ctrl+C Copy line (empty selection)
Alt+ ↑ / ↓ Move line up/down
Shift+Alt + ↓ / ↑ Copy line up/down
Ctrl+Shift+K Delete line
Ctrl+Enter Insert line below
Ctrl+Shift+Enter Insert line above
Ctrl+Shift+\ Jump to matching bracket
Ctrl+] / [ Indent/outdent line
Home / End Go to beginning/end of line
Ctrl+Home Go to beginning of file
Ctrl+End Go to end of file
Ctrl+↑ / ↓ Scroll line up/down
Alt+PgUp / PgDn Scroll page up/down
Ctrl+Shift+[ Fold (collapse) region
Ctrl+Shift+] Unfold (uncollapse) region
Ctrl+K Ctrl+[ Fold (collapse) all subregions
Ctrl+K Ctrl+] Unfold (uncollapse) all subregions
Ctrl+K Ctrl+0 Fold (collapse) all regions
Ctrl+K Ctrl+J Unfold (uncollapse) all regions
Ctrl+K Ctrl+C Add line comment
Ctrl+K Ctrl+U Remove line comment
Ctrl+/ Toggle line comment
Shift+Alt+A Toggle block comment
Alt+Z Toggle word wrap
---
Navigation
Ctrl+T Show all Symbols
Ctrl+G Go to Line...
Ctrl+P Go to File...
Ctrl+Shift+O Go to Symbol...
Ctrl+Shift+M Show Problems panel
F8 Go to next error or warning
Shift+F8 Go to previous error or warning
Ctrl+Shift+Tab Navigate editor group history
Alt+ ← / → Go back / forward
Ctrl+M Toggle Tab moves focus
---
Search and replace
Ctrl+F Find
Ctrl+H Replace
F3 / Shift+F3 Find next/previous
Alt+Enter Select all occurences of Find match
Ctrl+D Add selection to next Find match
Ctrl+K Ctrl+D Move last selection to next Find match
Alt+C / R / W Toggle case-sensitive / regex / whole word
---
Multi-cursor and selection
Alt+Click Insert cursor
Ctrl+Alt+ ↑ / ↓ Insert cursor above / below
Ctrl+U Undo last cursor operation
Shift+Alt+I Insert cursor at end of each line selected
Ctrl+L Select current line
Ctrl+Shift+L Select all occurrences of current selection
Ctrl+F2 Select all occurrences of current word
Shift+Alt+→ Expand selection
Shift+Alt+← Shrink selection
Shift+Alt +
(drag mouse)
Column (box) selection
Ctrl+Shift+Alt
+ (arrow key)
Column (box) selection
Ctrl+Shift+Alt
+PgUp/PgDn
Column (box) selection page up/down
---
Rich languages editing
Ctrl+Space, Ctrl+I Trigger suggestion
Ctrl+Shift+Space Trigger parameter hints
Shift+Alt+F Format document
Ctrl+K Ctrl+F Format selection
F12 Go to Definition
Alt+F12 Peek Definition
Ctrl+K F12 Open Definition to the side
Ctrl+. Quick Fix
Shift+F12 Show References
F2 Rename Symbol
Ctrl+K Ctrl+X Trim trailing whitespace
Ctrl+K M Change file language
---
Editor management
Ctrl+F4, Ctrl+W Close editor
Ctrl+K F Close folder
Ctrl+\ Split editor
Ctrl+ 1 / 2 / 3 Focus into 1st, 2nd or 3rd editor group
Ctrl+K Ctrl+ ←/→ Focus into previous/next editor group
Ctrl+Shift+PgUp / PgDn Move editor left/right
Ctrl+K ← / → Move active editor group
---
File management
Ctrl+N New File
Ctrl+O Open File...
Ctrl+S Save
Ctrl+Shift+S Save As...
Ctrl+K S Save All
Ctrl+F4 Close
Ctrl+K Ctrl+W Close All
Ctrl+Shift+T Reopen closed editor
Ctrl+K Enter Keep preview mode editor open
Ctrl+Tab Open next
Ctrl+Shift+Tab Open previous
Ctrl+K P Copy path of active file
Ctrl+K R Reveal active file in Explorer
Ctrl+K O Show active file in new window/instance
---
Display
F11 Toggle full screen
Shift+Alt+0 Toggle editor layout (horizontal/vertical)
Ctrl+ = / - Zoom in/out
Ctrl+B Toggle Sidebar visibility
Ctrl+Shift+E Show Explorer / Toggle focus
Ctrl+Shift+F Show Search
Ctrl+Shift+G Show Source Control
Ctrl+Shift+D Show Debug
Ctrl+Shift+X Show Extensions
Ctrl+Shift+H Replace in files
Ctrl+Shift+J Toggle Search details
Ctrl+Shift+U Show Output panel
Ctrl+Shift+V Open Markdown preview
Ctrl+K V Open Markdown preview to the side
Ctrl+K Z Zen Mode (Esc Esc to exit)
---
Debug
F9 Toggle breakpoint
F5 Start/Continue
Shift+F5 Stop
F11 / Shift+F11 Step into/out
F10 Step over
Ctrl+K Ctrl+I Show hover
---
Integrated terminal
Ctrl+` Show integrated terminal
Ctrl+Shift+` Create new terminal
Ctrl+C Copy selection
Ctrl+V Paste into active terminal
Ctrl+↑ / ↓ Scroll up/down
Shift+PgUp / PgDn Scroll page up/down
Ctrl+Home / End Scroll to top/bottom
---
Keyboard shortcuts for Windows
Other operating systems’ keyboard shortcuts and additional
unassigned shortcuts available at aka.ms/vscodekeybindings"
[{2026-03-25 retrieved} https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf]

name:::
* McsEngl.VscCmds!=Vscode'shortcut,
* McsEngl.Vscode'keybinding!⇒VscCmds,
* McsEngl.Vscode'keyboard-shortcut!⇒VscCmds,
* McsEngl.Vscode'shortcut!⇒VscCmds,

creating of VscCmds

description::
× HitpMcs-creation: {2026-04-01},

1) in %APPDATA%\Code\User\keybindings.json,
2) with extension creation in package.json,

name:::
* McsEngl.VscCmds'creating,

VscCmds.default

description::
× HitpMcs-creation: {2026-04-05},
× https://code.visualstudio.com/docs/reference/default-keybindings

* alt+-, decreaseSearchEditorContextLines, when: inSearchEditor,
* alt+-, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"decreaseSearchEditorContextLines"},
* alt+0, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.lastEditorInGroup"},
* alt+0, workbench.action.lastEditorInGroup,
* alt+1, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex1"},
* alt+1, workbench.action.openEditorAtIndex1,
* alt+2, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex2"},
* alt+2, workbench.action.openEditorAtIndex2,
* alt+3, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex3"},
* alt+3, workbench.action.openEditorAtIndex3,
* alt+4, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex4"},
* alt+4, workbench.action.openEditorAtIndex4,
* alt+5, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex5"},
* alt+5, workbench.action.openEditorAtIndex5,
* alt+6, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex6"},
* alt+6, workbench.action.openEditorAtIndex6,
* alt+7, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex7"},
* alt+7, workbench.action.openEditorAtIndex7,
* alt+8, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex8"},
* alt+8, workbench.action.openEditorAtIndex8,
* alt+9, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openEditorAtIndex9"},
* alt+9, workbench.action.openEditorAtIndex9,
* alt+=, increaseSearchEditorContextLines, when: inSearchEditor,
* alt+=, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"increaseSearchEditorContextLines"},
* alt+[, editor.action.accessibleViewPrevious, when: accessibleViewIsShown && accessibleViewSupportsNavigation,
* alt+[, editor.action.inlineSuggest.showPrevious, when: inlineSuggestionVisible && !editorReadonly,
* alt+[, kb-macro.wrap, when: accessibleViewIsShown && accessibleViewSupportsNavigation && kb-macro.active, args: {"command":"editor.action.accessibleViewPrevious"},
* alt+[, kb-macro.wrap, when: inlineSuggestionVisible && kb-macro.active && !editorReadonly, args: {"command":"editor.action.inlineSuggest.showPrevious","record":"side-effect"},
* alt+], editor.action.accessibleViewNext, when: accessibleViewIsShown && accessibleViewSupportsNavigation,
* alt+], editor.action.inlineSuggest.showNext, when: inlineSuggestionVisible && !editorReadonly,
* alt+], kb-macro.wrap, when: accessibleViewIsShown && accessibleViewSupportsNavigation && kb-macro.active, args: {"command":"editor.action.accessibleViewNext"},
* alt+], kb-macro.wrap, when: inlineSuggestionVisible && kb-macro.active && !editorReadonly, args: {"command":"editor.action.inlineSuggest.showNext","record":"side-effect"},
* alt+`, kb-macro.wrap, when: hasSpeechProvider && kb-macro.active && !editorReadonly && !speechToTextInProgress, args: {"command":"workbench.action.editorDictation.start"},
* alt+`, workbench.action.editorDictation.start, when: hasSpeechProvider && !editorReadonly && !speechToTextInProgress,
* alt+a, editor.action.accessibilityHelpConfigureAssignedKeybindings, when: accessibilityHelpIsShown && accessibleViewHasAssignedKeybindings,
* alt+a, kb-macro.wrap, when: accessibilityHelpIsShown && accessibleViewHasAssignedKeybindings && kb-macro.active, args: {"command":"editor.action.accessibilityHelpConfigureAssignedKeybindings"},
* alt+backspace, kb-macro.wrap, when: chatHasQuestionCarousel && kb-macro.active && !chatRemoteJobCreating || chatHasToolConfirmation && kb-macro.active && !chatRemoteJobCreating || chatSessionRequestInProgress && kb-macro.active && !chatRemoteJobCreating, args: {"command":"workbench.action.chat.cancel"},
* alt+backspace, kb-macro.wrap, when: commentWidgetVisible && editorFocus && kb-macro.active, args: {"command":"workbench.action.hideComment"},
* alt+backspace, workbench.action.chat.cancel, when: chatHasQuestionCarousel && !chatRemoteJobCreating || chatHasToolConfirmation && !chatRemoteJobCreating || chatSessionRequestInProgress && !chatRemoteJobCreating,
* alt+backspace, workbench.action.hideComment, when: commentWidgetVisible && editorFocus,
* alt+c, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"toggleFindCaseSensitive"},
* alt+c, kb-macro.wrap, when: inSearchEditor && kb-macro.active && searchInputBoxFocus, args: {"command":"toggleSearchEditorCaseSensitive"},
* alt+c, kb-macro.wrap, when: kb-macro.active && searchViewletFocus, args: {"command":"toggleSearchCaseSensitive"},
* alt+c, kb-macro.wrap, when: kb-macro.active && terminalFindVisible && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalProcessSupported, args: {"command":"workbench.action.terminal.toggleFindCaseSensitive"},
* alt+c, toggleFindCaseSensitive, when: editorFocus,
* alt+c, toggleSearchCaseSensitive, when: searchViewletFocus,
* alt+c, toggleSearchEditorCaseSensitive, when: inSearchEditor && searchInputBoxFocus,
* alt+c, workbench.action.terminal.toggleFindCaseSensitive, when: terminalFindVisible && terminalHasBeenCreated || terminalFindVisible && terminalProcessSupported,
* alt+delete, kb-macro.wrap, when: false, args: {"command":"deleteWordRight"},
* alt+delete, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bd"}},
* alt+delete, kb-macro.wrap, when: kb-macro.active && notebookCellEditable && notebookCellHasOutputs && notebookEditable && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.clearOutputs"},
* alt+delete, notebook.cell.clearOutputs, when: notebookCellEditable && notebookCellHasOutputs && notebookEditable && notebookEditorFocused && !inputFocus,
* alt+down, editor.action.moveLinesDownAction, when: editorTextFocus && !editorReadonly,
* alt+down, editor.action.pageDownHover, when: editorHoverFocused,
* alt+down, history.showNext, when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* alt+down, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.accessibleBufferGoToNextCommand"},
* alt+down, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.pageDownHover"},
* alt+down, kb-macro.wrap, when: editorPartModal && editorPartModalNavigation && kb-macro.active, args: {"command":"workbench.action.navigateModalEditorNext"},
* alt+down, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.moveLinesDownAction"},
* alt+down, kb-macro.wrap, when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible, args: {"command":"history.showNext"},
* alt+down, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.nextSeparatorWithQuickAccessFallback"},
* alt+down, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusAnyDown"},
* alt+down, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.moveDown"},
* alt+down, kb-macro.wrap, when: kb-macro.active && scmRepository, args: {"command":"scm.forceViewNextCommit"},
* alt+down, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive, args: {"command":"workbench.action.terminal.focusNextPane"},
* alt+down, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5B"}},
* alt+down, list.focusAnyDown, when: listFocus && !inputFocus && !treestickyScrollFocused,
* alt+down, notebook.cell.moveDown, when: notebookEditorFocused && !inputFocus,
* alt+down, quickInput.nextSeparatorWithQuickAccessFallback, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* alt+down, scm.forceViewNextCommit, when: scmRepository,
* alt+down, showNextParameterHint, when: editorFocus && kb-macro.active && parameterHintsMultipleSignatures && parameterHintsVisible,
* alt+down, showNextParameterHint, when: editorFocus && parameterHintsMultipleSignatures && parameterHintsVisible,
* alt+down, workbench.action.navigateModalEditorNext, when: editorPartModal && editorPartModalNavigation,
* alt+down, workbench.action.terminal.accessibleBufferGoToNextCommand, when: accessibleViewIsShown && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
* alt+down, workbench.action.terminal.focusNextPane, when: terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
* alt+down, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u001b[1;5B"},
* alt+end alt+end, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && mostRecentReplEditor || kb-macro.active && mostRecentReplEditor && !notebookCellListFocused, args: {"command":"repl.focusLastItemExecuted"},
* alt+end alt+end, repl.focusLastItemExecuted, when: isCompositeNotebook && mostRecentReplEditor || mostRecentReplEditor && !notebookCellListFocused,
* alt+end, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusAnyLast"},
* alt+end, list.focusAnyLast, when: listFocus && !inputFocus && !treestickyScrollFocused,
* alt+enter, debug.openBreakpointToSide, when: breakpointsFocused,
* alt+enter, editor.action.selectAllMatches, when: editorFocus && findWidgetVisible,
* alt+enter, kb-macro.wrap, when: breakpointsFocused && kb-macro.active, args: {"command":"debug.openBreakpointToSide"},
* alt+enter, kb-macro.wrap, when: chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st' && config.chat.requestQueuing.defaultAction != 'steer', args: {"command":"workbench.action.chat.steerWithMessage"},
* alt+enter, kb-macro.wrap, when: chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && config.chat.requestQueuing.defaultAction == 'steer' && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st', args: {"command":"workbench.action.chat.queueMessage"},
* alt+enter, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks, args: {"command":"workbench.action.terminal.chat.insertCommand"},
* alt+enter, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest, args: {"command":"workbench.action.terminal.chat.insertFirstCommand"},
* alt+enter, kb-macro.wrap, when: editorFocus && findWidgetVisible && kb-macro.active, args: {"command":"editor.action.selectAllMatches"},
* alt+enter, kb-macro.wrap, when: hasSearchResult && kb-macro.active && searchViewletFocus, args: {"command":"search.action.openInEditor"},
* alt+enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* alt+enter, kb-macro.wrap, when: kb-macro.active && focusedView == 'workbench.view.testing', args: {"command":"testing.editFocusedTest"},
* alt+enter, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && notebookCellType == 'markup' || kb-macro.active && notebookCellListFocused && notebookMissingKernelExtension && !notebookCellExecuting && notebookCellType == 'code' || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0, args: {"command":"notebook.cell.executeAndInsertBelow"},
* alt+enter, notebook.cell.executeAndInsertBelow, when: notebookCellListFocused && notebookCellType == 'markup' || notebookCellListFocused && notebookMissingKernelExtension && !notebookCellExecuting && notebookCellType == 'code' || notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0,
* alt+enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* alt+enter, search.action.openInEditor, when: hasSearchResult && searchViewletFocus,
* alt+enter, testing.editFocusedTest, when: focusedView == 'workbench.view.testing',
* alt+enter, workbench.action.chat.queueMessage, when: chatInputHasText && inChatInput && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatSessionRequestInProgress && inChatInput && config.chat.requestQueuing.defaultAction == 'steer' && chatInputHasText && chatSessionRequestInProgress && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's',
* alt+enter, workbench.action.chat.steerWithMessage, when: chatSessionRequestInProgress && inChatInput && chatInputHasText && chatSessionRequestInProgress && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st' && config.chat.requestQueuing.defaultAction != 'steer' || chatInputHasText && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's',
* alt+enter, workbench.action.terminal.chat.insertCommand, when: chatIsEnabled && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks,
* alt+enter, workbench.action.terminal.chat.insertFirstCommand, when: chatIsEnabled && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest,
* alt+escape, kb-macro.wrap, when: false, args: {"command":"editor.action.triggerSuggest","record":"side-effect"},
* alt+escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* alt+escape, quickInput.hide, when: inQuickInput,
* alt+f1, editor.action.accessibilityHelp, when: !accessibilityHelpIsShown,
* alt+f1, kb-macro.wrap, when: kb-macro.active && !accessibilityHelpIsShown, args: {"command":"editor.action.accessibilityHelp"},
* alt+f2, editor.action.accessibleView,
* alt+f2, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.focusAccessibleBuffer"},
* alt+f2, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.accessibleView"},
* alt+f2, workbench.action.terminal.focusAccessibleBuffer, when: accessibilityModeEnabled && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && terminalFocus && terminalProcessSupported,
* alt+f3, editor.action.dirtydiff.next, when: editorTextFocus && !textCompareEditorActive,
* alt+f3, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !textCompareEditorActive, args: {"command":"editor.action.dirtydiff.next"},
* alt+f3, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.notebookTextDiffEditor', args: {"command":"notebook.diff.action.next"},
* alt+f3, notebook.diff.action.next, when: activeEditor == 'workbench.editor.notebookTextDiffEditor',
* alt+f4, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeWindow"},
* alt+f4, workbench.action.closeWindow,
* alt+f5, chatEditor.action.navigateNext, when: chatEdits.hasEditorModifications && chatIsEnabled && editorFocus || chatEdits.hasEditorModifications && chatIsEnabled && notebookCellListFocused,
* alt+f5, kb-macro.wrap, when: chatEdits.hasEditorModifications && chatIsEnabled && editorFocus && kb-macro.active || chatEdits.hasEditorModifications && chatIsEnabled && kb-macro.active && notebookCellListFocused, args: {"command":"chatEditor.action.navigateNext"},
* alt+f5, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !textCompareEditorActive && quickDiffDecorationCount != '0', args: {"command":"workbench.action.editor.nextChange"},
* alt+f5, kb-macro.wrap, when: kb-macro.active && activeEditor == 'multiDiffEditor', args: {"command":"multiDiffEditor.goToNextChange"},
* alt+f5, kb-macro.wrap, when: kb-macro.active && textCompareEditorVisible, args: {"command":"workbench.action.compareEditor.nextChange"},
* alt+f5, multiDiffEditor.goToNextChange, when: activeEditor == 'multiDiffEditor',
* alt+f5, workbench.action.compareEditor.nextChange, when: textCompareEditorVisible,
* alt+f5, workbench.action.editor.nextChange, when: editorTextFocus && !textCompareEditorActive && quickDiffDecorationCount != '0',
* alt+f6, editor.action.accessibleViewDisableHint, when: accessibilityHelpIsShown && accessibleViewVerbosityEnabled || accessibleViewIsShown && accessibleViewVerbosityEnabled,
* alt+f6, kb-macro.wrap, when: accessibilityHelpIsShown && accessibleViewVerbosityEnabled && kb-macro.active || accessibleViewIsShown && accessibleViewVerbosityEnabled && kb-macro.active, args: {"command":"editor.action.accessibleViewDisableHint"},
* alt+f8, editor.action.marker.next, when: editorFocus,
* alt+f8, kb-macro.wrap, when: editorFocus && kb-macro.active && testing.isPeekVisible, args: {"command":"testing.goToNextMessage"},
* alt+f8, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.marker.next"},
* alt+f8, testing.goToNextMessage, when: editorFocus && testing.isPeekVisible,
* alt+f9, editor.action.nextCommentThreadAction,
* alt+f9, kb-macro.wrap, when: activeEditor && kb-macro.active && testing.hasCoverageInFile, args: {"command":"testing.coverage.goToNextMissedLine"},
* alt+f9, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.nextCommentThreadAction"},
* alt+f9, testing.coverage.goToNextMissedLine, when: activeEditor && testing.hasCoverageInFile,
* alt+f10, editor.action.nextCommentedRangeAction, when: activeEditorHasCommentingRange,
* alt+f10, kb-macro.wrap, when: activeEditorHasCommentingRange && kb-macro.active, args: {"command":"editor.action.nextCommentedRangeAction"},
* alt+f12, editor.action.peekDefinition, when: editorHasDefinitionProvider && editorTextFocus && !inReferenceSearchEditor && !isInEmbeddedEditor,
* alt+f12, kb-macro.wrap, when: editorHasDefinitionProvider && editorTextFocus && kb-macro.active && !inReferenceSearchEditor && !isInEmbeddedEditor, args: {"command":"editor.action.peekDefinition"},
* alt+h, editor.action.accessibilityHelpOpenHelpLink, when: accessibilityHelpIsShown,
* alt+h, kb-macro.wrap, when: accessibilityHelpIsShown && kb-macro.active, args: {"command":"editor.action.accessibilityHelpOpenHelpLink"},
* alt+h, kb-macro.wrap, when: kb-macro.active && testing.isPeekVisible, args: {"command":"testing.toggleTestingPeekHistory"},
* alt+h, testing.toggleTestingPeekHistory, when: testing.isPeekVisible,
* alt+home alt+home, kb-macro.wrap, when: kb-macro.active && mostRecentReplEditor, args: {"command":"repl.input.focus"},
* alt+home alt+home, repl.input.focus, when: mostRecentReplEditor,
* alt+home, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusAnyFirst"},
* alt+home, list.focusAnyFirst, when: listFocus && !inputFocus && !treestickyScrollFocused,
* alt+k, editor.action.accessibilityHelpConfigureKeybindings, when: accessibilityHelpIsShown && accessibleViewHasUnassignedKeybindings,
* alt+k, kb-macro.wrap, when: accessibilityHelpIsShown && accessibleViewHasUnassignedKeybindings && kb-macro.active, args: {"command":"editor.action.accessibilityHelpConfigureKeybindings"},
* alt+k, kb-macro.wrap, when: inKeybindings && inKeybindingsSearch && kb-macro.active, args: {"command":"keybindings.editor.recordSearchKeys"},
* alt+k, keybindings.editor.recordSearchKeys, when: inKeybindings && inKeybindingsSearch,
* alt+l, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"toggleFindInSelection"},
* alt+l, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"toggleSearchEditorContextLines"},
* alt+l, toggleFindInSelection, when: editorFocus,
* alt+l, toggleSearchEditorContextLines, when: inSearchEditor,
* alt+left, kb-macro.wrap, when: browserCanGoBack && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.goBack"},
* alt+left, kb-macro.wrap, when: canNavigateBack && kb-macro.active, args: {"command":"workbench.action.navigateBack"},
* alt+left, kb-macro.wrap, when: false, args: {"command":"breadcrumbs.focusPrevious"},
* alt+left, kb-macro.wrap, when: false, args: {"command":"breadcrumbs.focusPreviousWithPicker"},
* alt+left, kb-macro.wrap, when: false, args: {"command":"cursorWordLeft"},
* alt+left, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bb"}},
* alt+left, kb-macro.wrap, when: inQuickOpen && kb-macro.active, args: {"command":"workbench.action.quickInputBack"},
* alt+left, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive, args: {"command":"workbench.action.terminal.focusPreviousPane"},
* alt+left, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5D"}},
* alt+left, workbench.action.browser.goBack, when: browserCanGoBack && activeEditor == 'workbench.editor.browser',
* alt+left, workbench.action.navigateBack, when: canNavigateBack,
* alt+left, workbench.action.quickInputBack, when: inQuickOpen,
* alt+left, workbench.action.terminal.focusPreviousPane, when: terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
* alt+left, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u001b[1;5D"},
* alt+n, kb-macro.wrap, when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel && kb-macro.active, args: {"command":"workbench.action.chat.nextQuestion"},
* alt+n, workbench.action.chat.nextQuestion, when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel,
* alt+p, kb-macro.wrap, when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel && kb-macro.active, args: {"command":"workbench.action.chat.previousQuestion"},
* alt+p, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"togglePreserveCase"},
* alt+p, kb-macro.wrap, when: inKeybindings && kb-macro.active, args: {"command":"keybindings.editor.toggleSortByPrecedence"},
* alt+p, kb-macro.wrap, when: kb-macro.active && searchViewletFocus, args: {"command":"toggleSearchPreserveCase"},
* alt+p, keybindings.editor.toggleSortByPrecedence, when: inKeybindings,
* alt+p, togglePreserveCase, when: editorFocus,
* alt+p, toggleSearchPreserveCase, when: searchViewletFocus,
* alt+p, workbench.action.chat.previousQuestion, when: chatHasQuestionCarousel && inChat && inChatQuestionCarousel,
* alt+pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* alt+pagedown, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"scrollPageDown"},
* alt+pagedown, quickInput.pageNext, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* alt+pagedown, scrollPageDown, when: textInputFocus,
* alt+pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* alt+pageup, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"scrollPageUp"},
* alt+pageup, quickInput.pagePrevious, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* alt+pageup, scrollPageUp, when: textInputFocus,
* alt+r, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"toggleFindRegex"},
* alt+r, kb-macro.wrap, when: inSearchEditor && kb-macro.active && searchInputBoxFocus, args: {"command":"toggleSearchEditorRegex"},
* alt+r, kb-macro.wrap, when: kb-macro.active && searchViewletFocus, args: {"command":"toggleSearchRegex"},
* alt+r, kb-macro.wrap, when: kb-macro.active && terminalFindVisible && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalProcessSupported, args: {"command":"workbench.action.terminal.toggleFindRegex"},
* alt+r, toggleFindRegex, when: editorFocus,
* alt+r, toggleSearchEditorRegex, when: inSearchEditor && searchInputBoxFocus,
* alt+r, toggleSearchRegex, when: searchViewletFocus,
* alt+r, workbench.action.terminal.toggleFindRegex, when: terminalFindVisible && terminalHasBeenCreated || terminalFindVisible && terminalProcessSupported,
* alt+right, kb-macro.wrap, when: browserCanGoForward && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.goForward"},
* alt+right, kb-macro.wrap, when: canNavigateForward && kb-macro.active, args: {"command":"workbench.action.navigateForward"},
* alt+right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* alt+right, kb-macro.wrap, when: false, args: {"command":"breadcrumbs.focusNext"},
* alt+right, kb-macro.wrap, when: false, args: {"command":"breadcrumbs.focusNextWithPicker"},
* alt+right, kb-macro.wrap, when: false, args: {"command":"cursorWordEndRight"},
* alt+right, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bf"}},
* alt+right, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive, args: {"command":"workbench.action.terminal.focusNextPane"},
* alt+right, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5C"}},
* alt+right, quickInput.acceptInBackground, when: cursorAtEndOfQuickInputBox && inQuickInput && quickInputType == 'quickPick' || inQuickInput && !inputFocus && quickInputType == 'quickPick',
* alt+right, workbench.action.browser.goForward, when: browserCanGoForward && activeEditor == 'workbench.editor.browser',
* alt+right, workbench.action.navigateForward, when: canNavigateForward,
* alt+right, workbench.action.terminal.focusNextPane, when: terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
* alt+right, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u001b[1;5C"},
* alt+space, kb-macro.wrap, when: config.terminal.integrated.enableWin32InputMode && kb-macro.active && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[24~b"}},
* alt+space, workbench.action.terminal.sendSequence, when: config.terminal.integrated.enableWin32InputMode && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"text":"\u001b[24~b"},
* alt+t, kb-macro.wrap, when: accessibleViewIsShown && chatIsEnabled && kb-macro.active && accessibleViewCurrentProviderId == 'panelChat', args: {"command":"workbench.action.chat.toggleThinkingContentAccessibleView"},
* alt+t, workbench.action.chat.toggleThinkingContentAccessibleView, when: accessibleViewIsShown && chatIsEnabled && accessibleViewCurrentProviderId == 'panelChat',
* alt+up, editor.action.moveLinesUpAction, when: editorTextFocus && !editorReadonly,
* alt+up, editor.action.pageUpHover, when: editorHoverFocused,
* alt+up, history.showPrevious, when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* alt+up, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.accessibleBufferGoToPreviousCommand"},
* alt+up, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.pageUpHover"},
* alt+up, kb-macro.wrap, when: editorPartModal && editorPartModalNavigation && kb-macro.active, args: {"command":"workbench.action.navigateModalEditorPrevious"},
* alt+up, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.moveLinesUpAction"},
* alt+up, kb-macro.wrap, when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible, args: {"command":"history.showPrevious"},
* alt+up, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.previousSeparatorWithQuickAccessFallback"},
* alt+up, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusAnyUp"},
* alt+up, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.moveUp"},
* alt+up, kb-macro.wrap, when: kb-macro.active && scmRepository, args: {"command":"scm.forceViewPreviousCommit"},
* alt+up, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || kb-macro.active && terminalFocus && terminalProcessSupported && terminalSplitPaneActive, args: {"command":"workbench.action.terminal.focusPreviousPane"},
* alt+up, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;5A"}},
* alt+up, list.focusAnyUp, when: listFocus && !inputFocus && !treestickyScrollFocused,
* alt+up, notebook.cell.moveUp, when: notebookEditorFocused && !inputFocus,
* alt+up, quickInput.previousSeparatorWithQuickAccessFallback, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* alt+up, scm.forceViewPreviousCommit, when: scmRepository,
* alt+up, showPrevParameterHint, when: editorFocus && kb-macro.active && parameterHintsMultipleSignatures && parameterHintsVisible,
* alt+up, showPrevParameterHint, when: editorFocus && parameterHintsMultipleSignatures && parameterHintsVisible,
* alt+up, workbench.action.navigateModalEditorPrevious, when: editorPartModal && editorPartModalNavigation,
* alt+up, workbench.action.terminal.accessibleBufferGoToPreviousCommand, when: accessibleViewIsShown && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
* alt+up, workbench.action.terminal.focusPreviousPane, when: terminalFocus && terminalHasBeenCreated && terminalSplitPaneActive || terminalFocus && terminalProcessSupported && terminalSplitPaneActive,
* alt+up, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u001b[1;5A"},
* alt+w, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"toggleFindWholeWord"},
* alt+w, kb-macro.wrap, when: inSearchEditor && kb-macro.active && searchInputBoxFocus, args: {"command":"toggleSearchEditorWholeWord"},
* alt+w, kb-macro.wrap, when: kb-macro.active && searchViewletFocus, args: {"command":"toggleSearchWholeWord"},
* alt+w, kb-macro.wrap, when: kb-macro.active && terminalFindVisible && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalProcessSupported, args: {"command":"workbench.action.terminal.toggleFindWholeWord"},
* alt+w, toggleFindWholeWord, when: editorFocus,
* alt+w, toggleSearchEditorWholeWord, when: inSearchEditor && searchInputBoxFocus,
* alt+w, toggleSearchWholeWord, when: searchViewletFocus,
* alt+w, workbench.action.terminal.toggleFindWholeWord, when: terminalFindVisible && terminalHasBeenCreated || terminalFindVisible && terminalProcessSupported,
* alt+win+/, kb-macro.wrap, when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt', args: {"command":"workbench.action.chat.run.prompt.current"},
* alt+win+/, kb-macro.wrap, when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt', args: {"command":"workbench.action.chat.run.prompt.current"},
* alt+win+/, kb-macro.wrap, when: chatIsEnabled && kb-macro.active, args: {"command":"workbench.action.chat.run.prompt"},
* alt+win+/, kb-macro.wrap, when: chatIsEnabled && kb-macro.active, args: {"command":"workbench.action.chat.run.prompt"},
* alt+win+/, workbench.action.chat.run.prompt, when: chatIsEnabled,
* alt+win+/, workbench.action.chat.run.prompt.current, when: chatIsEnabled && editorTextFocus && resourceSet && resourceLangId == 'prompt',
* alt+win+backspace, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.removeBrackets"},
* alt+win+c, kb-macro.wrap, when: fileMatchOrFolderMatchWithResourceFocus && kb-macro.active, args: {"command":"search.action.copyPath"},
* alt+win+c, kb-macro.wrap, when: kb-macro.active && !editorFocus, args: {"command":"copyFilePath"},
* alt+win+c, kb-macro.wrap, when: kb-macro.active && searchViewletFocus && !fileMatchOrFolderMatchFocus, args: {"command":"toggleSearchCaseSensitive"},
* alt+win+c, kb-macro.wrap, when: kb-macro.active && watchExpressionsExist && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView', args: {"command":"debug.copyWatchExpression"},
* alt+win+down, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.insertCursorBelow"},
* alt+win+down, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.nextSeparator"},
* alt+win+enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* alt+win+escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* alt+win+j, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused, args: {"command":"notebook.cell.joinBelow"},
* alt+win+j, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused, args: {"command":"notebook.cell.joinBelow"},
* alt+win+j, notebook.cell.joinBelow, when: notebookEditorFocused,
* alt+win+left, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.previousEditor"},
* alt+win+pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* alt+win+pagedown, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollDown"},
* alt+win+pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* alt+win+pageup, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollUp"},
* alt+win+r, kb-macro.wrap, when: kb-macro.active && !editorFocus, args: {"command":"revealFileInOS"},
* alt+win+right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* alt+win+right, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.nextEditor"},
* alt+win+s, kb-macro.wrap, when: kb-macro.active, args: {"command":"saveAll"},
* alt+win+t, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeOtherEditors"},
* alt+win+up, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.insertCursorAbove"},
* alt+win+up, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.previousSeparator"},
* alt+z, editor.action.toggleWordWrap,
* alt+z, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported, args: {"command":"workbench.action.terminal.sizeToContentWidth"},
* alt+z, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.toggleWordWrap"},
* alt+z, workbench.action.terminal.sizeToContentWidth, when: terminalFocus && terminalHasBeenCreated && terminalIsOpen || terminalFocus && terminalIsOpen && terminalProcessSupported,
* backspace, deleteLeft, when: textInputFocus,
* backspace, kb-macro.wrap, when: config.notebook.multiCursor.enabled && isNotebookMultiSelect && kb-macro.active && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '1' || config.notebook.multiCursor.enabled && isNotebookMultiSelect && kb-macro.active && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '2', args: {"command":"noteMultiCursor.deleteLeft"},
* backspace, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"deleteLeft"},
* backspace, noteMultiCursor.deleteLeft, when: config.notebook.multiCursor.enabled && isNotebookMultiSelect && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '1' || config.notebook.multiCursor.enabled && isNotebookMultiSelect && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '2',
* browserback, kb-macro.wrap, when: browserCanGoBack && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.goBack"},
* browserback, kb-macro.wrap, when: canNavigateBack && kb-macro.active, args: {"command":"workbench.action.navigateBack"},
* browserback, workbench.action.browser.goBack, when: browserCanGoBack && activeEditor == 'workbench.editor.browser',
* browserback, workbench.action.navigateBack, when: canNavigateBack,
* browserforward, kb-macro.wrap, when: browserCanGoForward && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.goForward"},
* browserforward, kb-macro.wrap, when: canNavigateForward && kb-macro.active, args: {"command":"workbench.action.navigateForward"},
* browserforward, workbench.action.browser.goForward, when: browserCanGoForward && activeEditor == 'workbench.editor.browser',
* browserforward, workbench.action.navigateForward, when: canNavigateForward,
* ctrl+,, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openSettings"},
* ctrl+,, workbench.action.openSettings,
* ctrl+-, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.zoomOut"},
* ctrl+-, kb-macro.wrap, when: false, args: {"command":"workbench.action.navigateBack"},
* ctrl+-, kb-macro.wrap, when: false, args: {"command":"workbench.action.quickInputBack"},
* ctrl+-, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomOut"},
* ctrl+-, workbench.action.browser.zoomOut, when: browserFocused && browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+-, workbench.action.zoomOut,
* ctrl+., acceptSelectedCodeAction, when: codeActionMenuVisible && kb-macro.active,
* ctrl+., acceptSelectedCodeAction, when: codeActionMenuVisible,
* ctrl+., editor.action.quickFix, when: editorHasCodeActionsProvider && kb-macro.active && textInputFocus && !editorReadonly,
* ctrl+., editor.action.quickFix, when: editorHasCodeActionsProvider && textInputFocus && !editorReadonly,
* ctrl+., editor.changeDropType, when: dropWidgetVisible,
* ctrl+., editor.changePasteType, when: pasteWidgetVisible,
* ctrl+., kb-macro.wrap, when: chatIsEnabled && inChatInput && kb-macro.active && chatLocation == 'panel', args: {"command":"workbench.action.chat.openModePicker"},
* ctrl+., kb-macro.wrap, when: dropWidgetVisible && kb-macro.active, args: {"command":"editor.changeDropType"},
* ctrl+., kb-macro.wrap, when: kb-macro.active && notebookCellFocused && notebookCellHasErrorDiagnostics && !notebookCellEditorFocused, args: {"command":"notebook.cell.openFailureActions"},
* ctrl+., kb-macro.wrap, when: kb-macro.active && pasteWidgetVisible, args: {"command":"editor.changePasteType"},
* ctrl+., kb-macro.wrap, when: kb-macro.active && problemFocus, args: {"command":"problems.action.showQuickFixes"},
* ctrl+., kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.showQuickFixes"},
* ctrl+., notebook.cell.openFailureActions, when: notebookCellFocused && notebookCellHasErrorDiagnostics && !notebookCellEditorFocused,
* ctrl+., problems.action.showQuickFixes, when: problemFocus,
* ctrl+., workbench.action.chat.openModePicker, when: chatIsEnabled && inChatInput && chatLocation == 'panel',
* ctrl+., workbench.action.terminal.showQuickFixes, when: terminalFocus,
* ctrl+/, editor.action.accessibleViewAcceptInlineCompletion, when: accessibleViewIsShown && accessibleViewCurrentProviderId == 'inlineCompletions',
* ctrl+/, editor.action.commentLine, when: editorTextFocus && !editorReadonly,
* ctrl+/, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && accessibleViewCurrentProviderId == 'inlineCompletions', args: {"command":"editor.action.accessibleViewAcceptInlineCompletion"},
* ctrl+/, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.commentLine"},
* ctrl+/, kb-macro.wrap, when: inChatInput && kb-macro.active && chatLocation == 'panel', args: {"command":"workbench.action.chat.attachContext"},
* ctrl+/, kb-macro.wrap, when: kb-macro.active && notebookEditable && notebookEditorFocused && !inputFocus, args: {"command":"notebook.commentSelectedCells"},
* ctrl+/, kb-macro.wrap, when: kb-macro.active && suggestWidgetVisible, args: {"command":"toggleExplainMode","record":"side-effect"},
* ctrl+/, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"terminalSuggestToggleExplainMode"},
* ctrl+/, notebook.commentSelectedCells, when: notebookEditable && notebookEditorFocused && !inputFocus,
* ctrl+/, terminalSuggestToggleExplainMode, when: terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* ctrl+/, toggleExplainMode, when: suggestWidgetVisible,
* ctrl+/, workbench.action.chat.attachContext, when: inChatInput && chatLocation == 'panel',
* ctrl+0, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusSideBar"},
* ctrl+0, workbench.action.focusSideBar,
* ctrl+1, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusFirstEditorGroup"},
* ctrl+1, workbench.action.focusFirstEditorGroup,
* ctrl+2, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusSecondEditorGroup"},
* ctrl+2, workbench.action.focusSecondEditorGroup,
* ctrl+3, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusThirdEditorGroup"},
* ctrl+3, workbench.action.focusThirdEditorGroup,
* ctrl+4, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusFourthEditorGroup"},
* ctrl+4, workbench.action.focusFourthEditorGroup,
* ctrl+5, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusFifthEditorGroup"},
* ctrl+5, workbench.action.focusFifthEditorGroup,
* ctrl+6, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusSixthEditorGroup"},
* ctrl+6, workbench.action.focusSixthEditorGroup,
* ctrl+7, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusSeventhEditorGroup"},
* ctrl+7, workbench.action.focusSeventhEditorGroup,
* ctrl+8, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusEighthEditorGroup"},
* ctrl+8, workbench.action.focusEighthEditorGroup,
* ctrl+9, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.lastEditorInGroup"},
* ctrl+9, workbench.action.lastEditorInGroup,
* ctrl+; a, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.runAll"},
* ctrl+; a, testing.runAll,
* ctrl+; c, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"testing.runAtCursor"},
* ctrl+; c, testing.runAtCursor, when: editorTextFocus,
* ctrl+; ctrl+a, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.debugAll"},
* ctrl+; ctrl+a, testing.debugAll,
* ctrl+; ctrl+c, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"testing.debugAtCursor"},
* ctrl+; ctrl+c, testing.debugAtCursor, when: editorTextFocus,
* ctrl+; ctrl+e, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.debugFailTests"},
* ctrl+; ctrl+e, testing.debugFailTests,
* ctrl+; ctrl+f, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"testing.debugCurrentFile"},
* ctrl+; ctrl+f, testing.debugCurrentFile, when: editorTextFocus,
* ctrl+; ctrl+i, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.toggleInlineTestOutput"},
* ctrl+; ctrl+i, testing.toggleInlineTestOutput,
* ctrl+; ctrl+l, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.debugLastRun"},
* ctrl+; ctrl+l, testing.debugLastRun,
* ctrl+; ctrl+m, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.openOutputPeek"},
* ctrl+; ctrl+m, testing.openOutputPeek,
* ctrl+; ctrl+o, kb-macro.wrap, when: kb-macro.active && testing.hasAnyResults, args: {"command":"testing.showMostRecentOutput"},
* ctrl+; ctrl+o, testing.showMostRecentOutput, when: testing.hasAnyResults,
* ctrl+; ctrl+r, kb-macro.wrap, when: kb-macro.active && testing.canRefresh, args: {"command":"testing.refreshTests"},
* ctrl+; ctrl+r, testing.refreshTests, when: testing.canRefresh,
* ctrl+; ctrl+shift+a, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.coverageAll"},
* ctrl+; ctrl+shift+a, testing.coverageAll,
* ctrl+; ctrl+shift+c, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"testing.coverageAtCursor"},
* ctrl+; ctrl+shift+c, testing.coverageAtCursor, when: editorTextFocus,
* ctrl+; ctrl+shift+f, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"testing.coverageCurrentFile"},
* ctrl+; ctrl+shift+f, testing.coverageCurrentFile, when: editorTextFocus,
* ctrl+; ctrl+shift+i, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.toggleInlineCoverage"},
* ctrl+; ctrl+shift+i, testing.toggleInlineCoverage,
* ctrl+; ctrl+shift+l, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.coverageLastRun"},
* ctrl+; ctrl+shift+l, testing.coverageLastRun,
* ctrl+; ctrl+x, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.cancelRun"},
* ctrl+; ctrl+x, testing.cancelRun,
* ctrl+; e, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.reRunFailTests"},
* ctrl+; e, testing.reRunFailTests,
* ctrl+; f, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"testing.runCurrentFile"},
* ctrl+; f, testing.runCurrentFile, when: editorTextFocus,
* ctrl+; l, kb-macro.wrap, when: kb-macro.active, args: {"command":"testing.reRunLastRun"},
* ctrl+; l, testing.reRunLastRun,
* ctrl+=, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.zoomIn"},
* ctrl+=, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomIn"},
* ctrl+=, workbench.action.browser.zoomIn, when: browserFocused && browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+=, workbench.action.zoomIn,
* ctrl+[, editor.action.outdentLines, when: editorTextFocus && !editorReadonly,
* ctrl+[, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.outdentLines"},
* ctrl+\\, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.splitEditor"},
* ctrl+\\, workbench.action.splitEditor,
* ctrl+], editor.action.indentLines, when: editorTextFocus && !editorReadonly,
* ctrl+], kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.indentLines"},
* ctrl+`, kb-macro.wrap, when: kb-macro.active && terminal.active, args: {"command":"workbench.action.terminal.toggleTerminal"},
* ctrl+`, workbench.action.terminal.toggleTerminal, when: terminal.active,
* ctrl+a, editor.action.selectAll,
* ctrl+a, kb-macro.wrap, when: false, args: {"command":"cursorLineStart"},
* ctrl+a, kb-macro.wrap, when: kb-macro.active && listFocus && listSupportsMultiselect && !inputFocus && !treestickyScrollFocused, args: {"command":"list.selectAll"},
* ctrl+a, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && notebookOutputFocused, args: {"command":"notebook.cell.output.selectAll"},
* ctrl+a, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.selectAll"},
* ctrl+a, list.selectAll, when: listFocus && listSupportsMultiselect && !inputFocus && !treestickyScrollFocused,
* ctrl+a, notebook.cell.output.selectAll, when: notebookEditorFocused && notebookOutputFocused,
* ctrl+alt+-, kb-macro.wrap, when: false, args: {"command":"workbench.action.navigateBack"},
* ctrl+alt+-, kb-macro.wrap, when: false, args: {"command":"workbench.action.quickInputBack"},
* ctrl+alt+., github.copilot.chat.rerunWithCopilotDebug, when: github.copilot-chat.activated && terminalFocus && terminalShellIntegrationEnabled && !terminalAltBufferActive,
* ctrl+alt+., kb-macro.wrap, when: chatIsEnabled && inChatInput && kb-macro.active, args: {"command":"workbench.action.chat.openModelPicker"},
* ctrl+alt+., workbench.action.chat.openModelPicker, when: chatIsEnabled && inChatInput,
* ctrl+alt+/, kb-macro.wrap, when: false, args: {"command":"workbench.action.chat.run.prompt"},
* ctrl+alt+/, kb-macro.wrap, when: false, args: {"command":"workbench.action.chat.run.prompt.current"},
* ctrl+alt+b, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.toggleAuxiliaryBar"},
* ctrl+alt+b, workbench.action.toggleAuxiliaryBar,
* ctrl+alt+backspace, editor.action.removeBrackets, when: editorTextFocus,
* ctrl+alt+backspace, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.removeBrackets"},
* ctrl+alt+backspace, kb-macro.wrap, when: false, args: {"command":"deleteWordPartLeft"},
* ctrl+alt+c i, extension.charInsertInt, when: editorTextFocus,
* ctrl+alt+c, debug.copyWatchExpression, when: watchExpressionsExist && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView',
* ctrl+alt+c, kb-macro.wrap, when: false, args: {"command":"copyFilePath"},
* ctrl+alt+c, kb-macro.wrap, when: false, args: {"command":"search.action.copyPath"},
* ctrl+alt+c, kb-macro.wrap, when: kb-macro.active && watchExpressionsExist && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView', args: {"command":"debug.copyWatchExpression"},
* ctrl+alt+delete, kb-macro.wrap, when: false, args: {"command":"deleteWordPartRight"},
* ctrl+alt+down, editor.action.insertCursorBelow, when: editorTextFocus,
* ctrl+alt+down, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active, args: {"command":"workbench.action.chat.nextUserPrompt"},
* ctrl+alt+down, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.insertCursorBelow"},
* ctrl+alt+down, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.nextSeparator"},
* ctrl+alt+down, quickInput.nextSeparator, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+alt+down, workbench.action.chat.nextUserPrompt, when: chatIsEnabled && inChat,
* ctrl+alt+end, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.last"},
* ctrl+alt+end, quickInput.last, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+alt+enter, editor.action.replaceAll, when: editorFocus && findWidgetVisible,
* ctrl+alt+enter, kb-macro.wrap, when: accessibleViewInCodeBlock && chatIsEnabled && kb-macro.active || chatIsEnabled && inChat && kb-macro.active, args: {"command":"workbench.action.chat.runInTerminal"},
* ctrl+alt+enter, kb-macro.wrap, when: agentSessionsViewerFocused && kb-macro.active && !isSessionsWindow, args: {"command":"workbench.action.chat.openSessionInNewEditorGroup"},
* ctrl+alt+enter, kb-macro.wrap, when: chatHasToolConfirmation && inChat && kb-macro.active, args: {"command":"workbench.action.chat.skipTool"},
* ctrl+alt+enter, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks, args: {"command":"workbench.action.terminal.chat.insertCommand"},
* ctrl+alt+enter, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest, args: {"command":"workbench.action.terminal.chat.insertFirstCommand"},
* ctrl+alt+enter, kb-macro.wrap, when: editorFocus && findWidgetVisible && kb-macro.active, args: {"command":"editor.action.replaceAll"},
* ctrl+alt+enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* ctrl+alt+enter, kb-macro.wrap, when: inputFocus && kb-macro.active && notebookEditorFocused && !inlineChatFocused && notebookCellType == 'markup', args: {"command":"notebook.cell.quitEdit"},
* ctrl+alt+enter, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && notebookMissingKernelExtension && !notebookCellExecuting && notebookCellType == 'code' || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0, args: {"command":"notebook.cell.execute"},
* ctrl+alt+enter, kb-macro.wrap, when: kb-macro.active && replaceActive && searchViewletVisible && !findWidgetVisible, args: {"command":"search.action.replaceAll"},
* ctrl+alt+enter, notebook.cell.execute, when: notebookCellListFocused && notebookMissingKernelExtension && !notebookCellExecuting && notebookCellType == 'code' || notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0,
* ctrl+alt+enter, notebook.cell.quitEdit, when: inputFocus && notebookEditorFocused && !inlineChatFocused && notebookCellType == 'markup',
* ctrl+alt+enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* ctrl+alt+enter, search.action.replaceAll, when: replaceActive && searchViewletVisible && !findWidgetVisible,
* ctrl+alt+enter, workbench.action.chat.openSessionInNewEditorGroup, when: agentSessionsViewerFocused && !isSessionsWindow,
* ctrl+alt+enter, workbench.action.chat.runInTerminal, when: accessibleViewInCodeBlock && chatIsEnabled || chatIsEnabled && inChat,
* ctrl+alt+enter, workbench.action.chat.skipTool, when: chatHasToolConfirmation && inChat,
* ctrl+alt+enter, workbench.action.terminal.chat.insertCommand, when: chatIsEnabled && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks,
* ctrl+alt+enter, workbench.action.terminal.chat.insertFirstCommand, when: chatIsEnabled && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest,
* ctrl+alt+escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* ctrl+alt+escape, quickInput.hide, when: inQuickInput,
* ctrl+alt+f, kb-macro.wrap, when: inDebugRepl && kb-macro.active || inDebugRepl && kb-macro.active && focusedView == 'workbench.panel.repl.view', args: {"command":"repl.action.find"},
* ctrl+alt+f, kb-macro.wrap, when: kb-macro.active && listFocus && listSupportsFind, args: {"command":"list.find"},
* ctrl+alt+f, kb-macro.wrap, when: kb-macro.active && view == 'workbench.panel.repl.view', args: {"command":"list.find.replInputFocus"},
* ctrl+alt+f, list.find, when: listFocus && listSupportsFind,
* ctrl+alt+f, list.find.replInputFocus, when: view == 'workbench.panel.repl.view',
* ctrl+alt+f, repl.action.find, when: inDebugRepl || inDebugRepl && focusedView == 'workbench.panel.repl.view',
* ctrl+alt+g, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0007"}},
* ctrl+alt+g, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u0007"},
* ctrl+alt+h t, extension.htmlTagInsert, when: editorTextFocus,
* ctrl+alt+home, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.first"},
* ctrl+alt+home, quickInput.first, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+alt+i, kb-macro.wrap, when: kb-macro.active && !chatSetupDisabled && !chatSetupHidden, args: {"command":"workbench.action.chat.open"},
* ctrl+alt+i, kb-macro.wrap, when: kb-macro.active && workbench.panel.chat.view.copilot.active, args: {"command":"workbench.panel.chat"},
* ctrl+alt+i, workbench.action.chat.open, when: !chatSetupDisabled && !chatSetupHidden,
* ctrl+alt+i, workbench.panel.chat, when: workbench.panel.chat.view.copilot.active,
* ctrl+alt+j, kb-macro.wrap, when: false, args: {"command":"notebook.cell.joinBelow"},
* ctrl+alt+left, kb-macro.wrap, when: false, args: {"command":"cursorWordPartLeft"},
* ctrl+alt+left, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveEditorToPreviousGroup"},
* ctrl+alt+left, workbench.action.moveEditorToPreviousGroup,
* ctrl+alt+n, kb-macro.wrap, when: false, args: {"command":"list.focusAnyDown"},
* ctrl+alt+o, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.remote.showMenu"},
* ctrl+alt+o, workbench.action.remote.showMenu,
* ctrl+alt+p, kb-macro.cancelRecording, when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* ctrl+alt+p, kb-macro.playback, when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* ctrl+alt+p, kb-macro.wrap, when: false, args: {"command":"list.focusAnyUp"},
* ctrl+alt+pagedown, editor.action.accessibleViewNextCodeBlock, when: accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'quickChat',
* ctrl+alt+pagedown, kb-macro.wrap, when: accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'quickChat', args: {"command":"editor.action.accessibleViewNextCodeBlock"},
* ctrl+alt+pagedown, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active, args: {"command":"workbench.action.chat.nextCodeBlock"},
* ctrl+alt+pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* ctrl+alt+pagedown, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollDown"},
* ctrl+alt+pagedown, quickInput.pageNext, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+alt+pagedown, workbench.action.chat.nextCodeBlock, when: chatIsEnabled && inChat,
* ctrl+alt+pagedown, workbench.action.terminal.scrollDown, when: terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
* ctrl+alt+pageup, editor.action.accessibleViewPreviousCodeBlock, when: accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && accessibleViewCurrentProviderId == 'quickChat',
* ctrl+alt+pageup, kb-macro.wrap, when: accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'inlineChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'panelChat' || accessibleViewContainsCodeBlocks && kb-macro.active && accessibleViewCurrentProviderId == 'quickChat', args: {"command":"editor.action.accessibleViewPreviousCodeBlock"},
* ctrl+alt+pageup, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active, args: {"command":"workbench.action.chat.previousCodeBlock"},
* ctrl+alt+pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* ctrl+alt+pageup, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollUp"},
* ctrl+alt+pageup, quickInput.pagePrevious, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+alt+pageup, workbench.action.chat.previousCodeBlock, when: chatIsEnabled && inChat,
* ctrl+alt+pageup, workbench.action.terminal.scrollUp, when: terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
* ctrl+alt+r, kb-macro.finishRecording, when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* ctrl+alt+r, kb-macro.startRecording, when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option1',
* ctrl+alt+r, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0012"}},
* ctrl+alt+r, kb-macro.wrap, when: false, args: {"command":"revealFileInOS"},
* ctrl+alt+r, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || kb-macro.active && terminalFocus && terminalProcessSupported && !accessibilityModeEnabled, args: {"command":"workbench.action.terminal.runRecentCommand"},
* ctrl+alt+r, workbench.action.terminal.runRecentCommand, when: terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || terminalFocus && terminalProcessSupported && !accessibilityModeEnabled,
* ctrl+alt+r, workbench.action.terminal.sendSequence, when: accessibilityModeEnabled && terminalFocus, args: {"text":"\u0012"},
* ctrl+alt+right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* ctrl+alt+right, kb-macro.wrap, when: false, args: {"command":"cursorWordPartRight"},
* ctrl+alt+right, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveEditorToNextGroup"},
* ctrl+alt+right, quickInput.acceptInBackground, when: cursorAtEndOfQuickInputBox && inQuickInput && quickInputType == 'quickPick' || inQuickInput && !inputFocus && quickInputType == 'quickPick',
* ctrl+alt+right, workbench.action.moveEditorToNextGroup,
* ctrl+alt+space, kb-macro.wrap, when: kb-macro.active && !textInputFocus, args: {"command":"workbench.action.terminal.suggestToggleDetailsFocus"},
* ctrl+alt+space, kb-macro.wrap, when: kb-macro.active && suggestWidgetVisible && textInputFocus, args: {"command":"toggleSuggestionFocus","record":"side-effect"},
* ctrl+alt+space, toggleSuggestionFocus, when: suggestWidgetVisible && textInputFocus,
* ctrl+alt+space, workbench.action.terminal.suggestToggleDetailsFocus, when: !textInputFocus,
* ctrl+alt+t, extension.userInput, when: editorTextFocus,
* ctrl+alt+up, editor.action.insertCursorAbove, when: editorTextFocus,
* ctrl+alt+up, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active, args: {"command":"workbench.action.chat.previousUserPrompt"},
* ctrl+alt+up, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.insertCursorAbove"},
* ctrl+alt+up, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.previousSeparator"},
* ctrl+alt+up, quickInput.previousSeparator, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+alt+up, workbench.action.chat.previousUserPrompt, when: chatIsEnabled && inChat,
* ctrl+alt+v, kb-macro.wrap, when: hasSpeechProvider && kb-macro.active && !editorReadonly && !speechToTextInProgress, args: {"command":"workbench.action.editorDictation.start"},
* ctrl+alt+v, workbench.action.editorDictation.start, when: hasSpeechProvider && !editorReadonly && !speechToTextInProgress,
* ctrl+alt+win+/, kb-macro.wrap, when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt', args: {"command":"workbench.action.chat.run-in-new-chat.prompt.current"},
* ctrl+alt+win+/, kb-macro.wrap, when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt', args: {"command":"workbench.action.chat.run-in-new-chat.prompt.current"},
* ctrl+alt+win+/, kb-macro.wrap, when: chatIsEnabled && editorTextFocus && kb-macro.active && resourceSet && resourceLangId == 'prompt', args: {"command":"workbench.action.chat.run-in-new-chat.prompt.current"},
* ctrl+alt+win+/, workbench.action.chat.run-in-new-chat.prompt.current, when: chatIsEnabled && editorTextFocus && resourceSet && resourceLangId == 'prompt',
* ctrl+alt+win+end, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.last"},
* ctrl+alt+win+enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* ctrl+alt+win+escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* ctrl+alt+win+home, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.first"},
* ctrl+alt+win+n, kb-macro.wrap, when: kb-macro.active, args: {"command":"welcome.showNewFileEntries"},
* ctrl+alt+win+n, kb-macro.wrap, when: kb-macro.active, args: {"command":"welcome.showNewFileEntries"},
* ctrl+alt+win+n, kb-macro.wrap, when: kb-macro.active, args: {"command":"welcome.showNewFileEntries"},
* ctrl+alt+win+n, welcome.showNewFileEntries,
* ctrl+alt+win+pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* ctrl+alt+win+pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* ctrl+alt+win+right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* ctrl+alt+y, chatEditor.action.acceptAllEdits, when: chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
* ctrl+alt+y, kb-macro.wrap, when: chatEdits.hasEditorModifications && editorFocus && kb-macro.active && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && kb-macro.active && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified, args: {"command":"chatEditor.action.acceptAllEdits"},
* ctrl+b, kb-macro.wrap, when: false, args: {"command":"cursorLeft"},
* ctrl+b, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.toggleSidebarVisibility"},
* ctrl+b, workbench.action.toggleSidebarVisibility,
* ctrl+backspace, chatEditing.discardAllFiles, when: hasUndecidedChatEditingResource && inChatInput && !chatInputHasText,
* ctrl+backspace, deleteWordLeft, when: textInputFocus && !editorReadonly,
* ctrl+backspace, kb-macro.wrap, when: false, args: {"command":"deleteLeft"},
* ctrl+backspace, kb-macro.wrap, when: hasUndecidedChatEditingResource && inChatInput && kb-macro.active && !chatInputHasText, args: {"command":"chatEditing.discardAllFiles"},
* ctrl+backspace, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalShellType == 'cmd', args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\b"}},
* ctrl+backspace, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0017"}},
* ctrl+backspace, kb-macro.wrap, when: kb-macro.active && textInputFocus && !editorReadonly, args: {"command":"deleteWordLeft"},
* ctrl+backspace, workbench.action.terminal.sendSequence, when: terminalFocus && terminalShellType == 'cmd', args: {"text":"\b"},
* ctrl+backspace, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u0017"},
* ctrl+c, chat.inlineResourceAnchor.copyResource, when: chatAttachmentResource,
* ctrl+c, editor.action.clipboardCopyAction,
* ctrl+c, filesExplorer.copy, when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsRoot && !inputFocus,
* ctrl+c, kb-macro.wrap, when: chatAttachmentResource && kb-macro.active, args: {"command":"chat.inlineResourceAnchor.copyResource"},
* ctrl+c, kb-macro.wrap, when: fileMatchOrMatchFocus && kb-macro.active, args: {"command":"search.action.copyMatch"},
* ctrl+c, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceIsRoot && !inputFocus, args: {"command":"filesExplorer.copy"},
* ctrl+c, kb-macro.wrap, when: inKeybindings && kb-macro.active && keybindingFocus && !whenFocus, args: {"command":"keybindings.editor.copyKeybindingEntry"},
* ctrl+c, kb-macro.wrap, when: kb-macro.active && !expressionSelected && focusedView == 'workbench.debug.variablesView' || kb-macro.active && !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView', args: {"command":"workbench.debug.viewlet.action.copyValue"},
* ctrl+c, kb-macro.wrap, when: kb-macro.active && problemsVisibility && !relatedInformationFocus && focusedView == 'workbench.panel.markers.view', args: {"command":"problems.action.copy"},
* ctrl+c, kb-macro.wrap, when: kb-macro.active && suggestWidgetDetailsFocused, args: {"command":"suggestWidgetCopy"},
* ctrl+c, kb-macro.wrap, when: kb-macro.active && terminalTextSelectedInFocused || kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalTextSelected || kb-macro.active && terminalFocus && terminalProcessSupported && terminalTextSelected || kb-macro.active && terminalFocus && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalHasBeenCreated && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalProcessSupported && terminalTextSelected && terminalTextSelectedInFocused, args: {"command":"workbench.action.terminal.copyAndClearSelection"},
* ctrl+c, kb-macro.wrap, when: kb-macro.active && tunnelViewFocus && tunnelType == 'Detected' && tunnelViewMultiSelection == 'undefined' || kb-macro.active && tunnelViewFocus && tunnelType == 'Forwarded' && tunnelViewMultiSelection == 'undefined', args: {"command":"remote.tunnel.copyAddressInline"},
* ctrl+c, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.clipboardCopyAction","await":"clipboard"},
* ctrl+c, keybindings.editor.copyKeybindingEntry, when: inKeybindings && keybindingFocus && !whenFocus,
* ctrl+c, problems.action.copy, when: problemsVisibility && !relatedInformationFocus && focusedView == 'workbench.panel.markers.view',
* ctrl+c, remote.tunnel.copyAddressInline, when: tunnelViewFocus && tunnelType == 'Detected' && tunnelViewMultiSelection == 'undefined' || tunnelViewFocus && tunnelType == 'Forwarded' && tunnelViewMultiSelection == 'undefined',
* ctrl+c, search.action.copyMatch, when: fileMatchOrMatchFocus,
* ctrl+c, suggestWidgetCopy, when: suggestWidgetDetailsFocused,
* ctrl+c, workbench.action.terminal.copyAndClearSelection, when: terminalTextSelectedInFocused || terminalFocus && terminalHasBeenCreated && terminalTextSelected || terminalFocus && terminalProcessSupported && terminalTextSelected || terminalFocus && terminalTextSelected && terminalTextSelectedInFocused || terminalHasBeenCreated && terminalTextSelected && terminalTextSelectedInFocused || terminalProcessSupported && terminalTextSelected && terminalTextSelectedInFocused,
* ctrl+c, workbench.debug.viewlet.action.copyValue, when: !expressionSelected && focusedView == 'workbench.debug.variablesView' || !expressionSelected && focusedView == 'workbench.debug.watchExpressionsView',
* ctrl+d, editor.action.addSelectionToNextFindMatch, when: editorFocus,
* ctrl+d, kb-macro.wrap, when: config.notebook.multiCursor.enabled && kb-macro.active && notebookCellEditorFocused && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.addFindMatchToSelection"},
* ctrl+d, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.addSelectionToNextFindMatch"},
* ctrl+d, kb-macro.wrap, when: false, args: {"command":"deleteRight"},
* ctrl+d, notebook.addFindMatchToSelection, when: config.notebook.multiCursor.enabled && notebookCellEditorFocused && activeEditor == 'workbench.editor.notebook',
* ctrl+delete, deleteWordRight, when: textInputFocus && !editorReadonly,
* ctrl+delete, kb-macro.wrap, when: false, args: {"command":"deleteRight"},
* ctrl+delete, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001bd"}},
* ctrl+delete, kb-macro.wrap, when: kb-macro.active && textInputFocus && !editorReadonly, args: {"command":"deleteWordRight"},
* ctrl+delete, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u001bd"},
* ctrl+down, chat.action.focus, when: inChat && inChatInput && quickChatHasFocus,
* ctrl+down, commentsFocusViewFromFilter, when: commentsFilterFocus,
* ctrl+down, editor.action.goToBottomHover, when: editorHoverFocused,
* ctrl+down, inlineChat.focus, when: editorTextFocus && inlineChatVisible && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'above',
* ctrl+down, kb-macro.wrap, when: accessibilityModeEnabled && accessibleViewOnLastLine && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibilityModeEnabled && accessibleViewOnLastLine && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.focus"},
* ctrl+down, kb-macro.wrap, when: commentsFilterFocus && kb-macro.active, args: {"command":"commentsFocusViewFromFilter"},
* ctrl+down, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.goToBottomHover"},
* ctrl+down, kb-macro.wrap, when: editorTextFocus && inlineChatVisible && kb-macro.active && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'above', args: {"command":"inlineChat.focus"},
* ctrl+down, kb-macro.wrap, when: inChat && inChatInput && kb-macro.active && quickChatHasFocus, args: {"command":"chat.action.focus"},
* ctrl+down, kb-macro.wrap, when: inChat && kb-macro.active && !inChatInput && !quickChatHasFocus, args: {"command":"workbench.action.chat.focusInput"},
* ctrl+down, kb-macro.wrap, when: inKeybindings && inKeybindingsSearch && kb-macro.active, args: {"command":"keybindings.editor.focusKeybindings"},
* ctrl+down, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.next"},
* ctrl+down, kb-macro.wrap, when: inSearchEditor && inputBoxFocus && kb-macro.active || inputBoxFocus && kb-macro.active && searchViewletVisible, args: {"command":"search.focus.nextInputBox"},
* ctrl+down, kb-macro.wrap, when: inputFocus && kb-macro.active && navigableContainerFocused || kb-macro.active && navigableContainerFocused && treestickyScrollFocused || kb-macro.active && navigableContainerFocused && !listFocus || kb-macro.active && navigableContainerFocused && listScrollAtBoundary == 'both' || kb-macro.active && navigableContainerFocused && listScrollAtBoundary == 'bottom', args: {"command":"widgetNavigation.focusNext"},
* ctrl+down, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && notebookEditorFocused, args: {"command":"repl.input.focus"},
* ctrl+down, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused && listScrollAtBoundary != 'both' && listScrollAtBoundary != 'bottom', args: {"command":"list.scrollDown"},
* ctrl+down, kb-macro.wrap, when: kb-macro.active && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.interactive' || kb-macro.active && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.notebook' || kb-macro.active && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.repl', args: {"command":"notebook.cell.focusInOutput"},
* ctrl+down, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && notebookOutputFocused, args: {"command":"notebook.focusNextEditor"},
* ctrl+down, kb-macro.wrap, when: kb-macro.active && problemsFilterFocus, args: {"command":"problems.action.focusProblemsFromFilter"},
* ctrl+down, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectNextSuggestion","record":"side-effect"},
* ctrl+down, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || kb-macro.active && terminalFocus && terminalProcessSupported && !accessibilityModeEnabled, args: {"command":"workbench.action.terminal.scrollToNextCommand"},
* ctrl+down, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"scrollLineDown"},
* ctrl+down, keybindings.editor.focusKeybindings, when: inKeybindings && inKeybindingsSearch,
* ctrl+down, list.scrollDown, when: listFocus && !inputFocus && !treestickyScrollFocused && listScrollAtBoundary != 'both' && listScrollAtBoundary != 'bottom',
* ctrl+down, notebook.cell.focusInOutput, when: isWindows && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.interactive' || isWindows && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.notebook' || isWindows && notebookCellHasOutputs && !isCompositeNotebook && activeEditor == 'workbench.editor.repl',
* ctrl+down, notebook.focusNextEditor, when: notebookEditorFocused && notebookOutputFocused,
* ctrl+down, problems.action.focusProblemsFromFilter, when: problemsFilterFocus,
* ctrl+down, quickInput.next, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+down, repl.input.focus, when: isCompositeNotebook && notebookEditorFocused,
* ctrl+down, scrollLineDown, when: textInputFocus,
* ctrl+down, search.focus.nextInputBox, when: inSearchEditor && inputBoxFocus || inputBoxFocus && searchViewletVisible,
* ctrl+down, selectNextCodeAction, when: codeActionMenuVisible && kb-macro.active,
* ctrl+down, selectNextCodeAction, when: codeActionMenuVisible,
* ctrl+down, selectNextSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* ctrl+down, widgetNavigation.focusNext, when: inputFocus && navigableContainerFocused || navigableContainerFocused && treestickyScrollFocused || navigableContainerFocused && !listFocus || navigableContainerFocused && listScrollAtBoundary == 'both' || navigableContainerFocused && listScrollAtBoundary == 'bottom',
* ctrl+down, workbench.action.chat.focusInput, when: inChat && !inChatInput && !quickChatHasFocus,
* ctrl+down, workbench.action.terminal.focus, when: accessibilityModeEnabled && accessibleViewOnLastLine && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibilityModeEnabled && accessibleViewOnLastLine && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
* ctrl+down, workbench.action.terminal.scrollToNextCommand, when: terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || terminalFocus && terminalProcessSupported && !accessibilityModeEnabled,
* ctrl+e, editor.action.toggleScreenReaderAccessibilityMode, when: accessibilityHelpIsShown,
* ctrl+e, kb-macro.wrap, when: accessibilityHelpIsShown && kb-macro.active, args: {"command":"editor.action.toggleScreenReaderAccessibilityMode"},
* ctrl+e, kb-macro.wrap, when: false, args: {"command":"cursorLineEnd"},
* ctrl+e, kb-macro.wrap, when: inFilesPicker && inQuickOpen && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigateNextInFilePicker"},
* ctrl+e, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.quickOpen"},
* ctrl+e, workbench.action.quickOpen,
* ctrl+e, workbench.action.quickOpenNavigateNextInFilePicker, when: inFilesPicker && inQuickOpen,
* ctrl+end, cursorBottom, when: textInputFocus,
* ctrl+end, interactive.scrollToBottom, when: activeEditor == 'workbench.editor.interactive',
* ctrl+end, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.scrollToBottomAccessibleView"},
* ctrl+end, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.last"},
* ctrl+end, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.interactive', args: {"command":"interactive.scrollToBottom"},
* ctrl+end, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.focusBottom"},
* ctrl+end, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollToBottom"},
* ctrl+end, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorBottom"},
* ctrl+end, notebook.focusBottom, when: notebookEditorFocused && !inputFocus,
* ctrl+end, quickInput.last, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+end, workbench.action.terminal.scrollToBottom, when: terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
* ctrl+end, workbench.action.terminal.scrollToBottomAccessibleView, when: accessibleViewIsShown && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
* ctrl+enter, acceptRenameInputWithPreview, when: config.editor.rename.enablePreview && editorFocus && renameInputVisible && !isComposing,
* ctrl+enter, breadcrumbs.revealFocused, when: breadcrumbsActive && breadcrumbsVisible,
* ctrl+enter, breadcrumbs.revealFocusedFromTreeAside, when: breadcrumbsActive && breadcrumbsVisible && listFocus && !inputFocus && !treestickyScrollFocused,
* ctrl+enter, chat.inlineResourceAnchor.openToSide, when: chatAttachmentResource,
* ctrl+enter, chatEditing.acceptAllFiles, when: hasUndecidedChatEditingResource && inChatInput,
* ctrl+enter, debug.openBreakpointToSide, when: breakpointsFocused,
* ctrl+enter, editor.action.insertLineAfter, when: editorTextFocus && !editorReadonly,
* ctrl+enter, editor.action.submitComment, when: commentEditorFocused,
* ctrl+enter, explorer.openToSide, when: explorerViewletFocus && foldersViewVisible && !inputFocus,
* ctrl+enter, github.copilot.nes.captureExpected.confirm, when: copilotNesCaptureMode && editorTextFocus,
* ctrl+enter, inlineChat2.keep, when: chatEdits.hasEditorModifications && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.isRequestInProgress || chatEdits.hasEditorModifications && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.isRequestInProgress && activeEditor == 'workbench.editor.notebook',
* ctrl+enter, interactive.execute, when: isCompositeNotebook && activeEditor == 'workbench.editor.interactive',
* ctrl+enter, kb-macro.wrap, when: accessibleViewInCodeBlock && chatIsEnabled && kb-macro.active || chatIsEnabled && inChat && kb-macro.active && !inChatInput, args: {"command":"workbench.action.chat.applyInEditor"},
* ctrl+enter, kb-macro.wrap, when: accessibleViewInCodeBlock && chatIsEnabled && kb-macro.active || chatIsEnabled && inChat && kb-macro.active && !inChatInput, args: {"command":"workbench.action.chat.insertCodeBlock"},
* ctrl+enter, kb-macro.wrap, when: agentSessionsViewerFocused && kb-macro.active && !isSessionsWindow, args: {"command":"workbench.action.chat.openSessionInEditorGroup"},
* ctrl+enter, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"breadcrumbs.revealFocusedFromTreeAside"},
* ctrl+enter, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.revealFocused"},
* ctrl+enter, kb-macro.wrap, when: breakpointsFocused && kb-macro.active, args: {"command":"debug.openBreakpointToSide"},
* ctrl+enter, kb-macro.wrap, when: browserElementSelectionActive && browserFocused && kb-macro.active, args: {"command":"workbench.action.browser.addFocusedElementToChat"},
* ctrl+enter, kb-macro.wrap, when: chatAttachmentResource && kb-macro.active, args: {"command":"chat.inlineResourceAnchor.openToSide"},
* ctrl+enter, kb-macro.wrap, when: chatEdits.hasEditorModifications && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active && !chatEdits.isRequestInProgress || chatEdits.hasEditorModifications && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && !chatEdits.isRequestInProgress && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat2.keep"},
* ctrl+enter, kb-macro.wrap, when: chatHasElicitationRequest && inChat && kb-macro.active, args: {"command":"workbench.action.chat.acceptElicitation"},
* ctrl+enter, kb-macro.wrap, when: chatHasToolConfirmation && inChat && kb-macro.active, args: {"command":"workbench.action.chat.acceptTool"},
* ctrl+enter, kb-macro.wrap, when: chatInputHasText && inChatInput && kb-macro.active && !chatSessionRequestInProgress, args: {"command":"workbench.action.chat.submitWithCodebase"},
* ctrl+enter, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && kb-macro.active && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks, args: {"command":"workbench.action.terminal.chat.runCommand"},
* ctrl+enter, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest, args: {"command":"workbench.action.terminal.chat.runFirstCommand"},
* ctrl+enter, kb-macro.wrap, when: commentEditorFocused && kb-macro.active, args: {"command":"editor.action.submitComment"},
* ctrl+enter, kb-macro.wrap, when: config.editor.rename.enablePreview && editorFocus && kb-macro.active && renameInputVisible && !isComposing, args: {"command":"acceptRenameInputWithPreview"},
* ctrl+enter, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.insertLineAfter"},
* ctrl+enter, kb-macro.wrap, when: explorerViewletFocus && foldersViewVisible && kb-macro.active && !inputFocus, args: {"command":"explorer.openToSide"},
* ctrl+enter, kb-macro.wrap, when: false, args: {"command":"notebook.cell.execute"},
* ctrl+enter, kb-macro.wrap, when: false, args: {"command":"notebook.cell.quitEdit"},
* ctrl+enter, kb-macro.wrap, when: fileMatchOrMatchFocus && kb-macro.active && searchViewletVisible, args: {"command":"search.action.openResultToSide"},
* ctrl+enter, kb-macro.wrap, when: hasUndecidedChatEditingResource && inChatInput && kb-macro.active, args: {"command":"chatEditing.acceptAllFiles"},
* ctrl+enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* ctrl+enter, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !notebookCellListFocused && activeEditor == 'workbench.editor.repl', args: {"command":"repl.execute"},
* ctrl+enter, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && activeEditor == 'workbench.editor.interactive', args: {"command":"interactive.execute"},
* ctrl+enter, kb-macro.wrap, when: isMergeEditor && kb-macro.active, args: {"command":"mergeEditor.acceptMerge"},
* ctrl+enter, kb-macro.wrap, when: kb-macro.active && listFocus && referenceSearchVisible && !inputFocus && !treeElementCanCollapse && !treeElementCanExpand && !treestickyScrollFocused, args: {"command":"openReferenceToSide"},
* ctrl+enter, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && !inputFocus, args: {"command":"notebook.cell.insertCodeCellBelow"},
* ctrl+enter, kb-macro.wrap, when: kb-macro.active && problemFocus, args: {"command":"problems.action.openToSide"},
* ctrl+enter, kb-macro.wrap, when: kb-macro.active && refactorPreview.enabled && refactorPreview.hasCheckedChanges && focusedView == 'refactorPreview', args: {"command":"refactorPreview.apply"},
* ctrl+enter, kb-macro.wrap, when: kb-macro.active && scmRepository, args: {"command":"scm.acceptInput"},
* ctrl+enter, mergeEditor.acceptMerge, when: isMergeEditor,
* ctrl+enter, notebook.cell.insertCodeCellBelow, when: notebookCellListFocused && !inputFocus,
* ctrl+enter, openReferenceToSide, when: listFocus && referenceSearchVisible && !inputFocus && !treeElementCanCollapse && !treeElementCanExpand && !treestickyScrollFocused,
* ctrl+enter, previewSelectedCodeAction, when: codeActionMenuVisible && kb-macro.active,
* ctrl+enter, previewSelectedCodeAction, when: codeActionMenuVisible,
* ctrl+enter, problems.action.openToSide, when: problemFocus,
* ctrl+enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* ctrl+enter, refactorPreview.apply, when: refactorPreview.enabled && refactorPreview.hasCheckedChanges && focusedView == 'refactorPreview',
* ctrl+enter, repl.execute, when: isCompositeNotebook && !notebookCellListFocused && activeEditor == 'workbench.editor.repl',
* ctrl+enter, scm.acceptInput, when: scmRepository,
* ctrl+enter, search.action.openResultToSide, when: fileMatchOrMatchFocus && searchViewletVisible,
* ctrl+enter, workbench.action.browser.addFocusedElementToChat, when: browserElementSelectionActive && browserFocused,
* ctrl+enter, workbench.action.chat.acceptElicitation, when: chatHasElicitationRequest && inChat,
* ctrl+enter, workbench.action.chat.acceptTool, when: chatHasToolConfirmation && inChat,
* ctrl+enter, workbench.action.chat.applyInEditor, when: accessibleViewInCodeBlock && chatIsEnabled || chatIsEnabled && inChat && !inChatInput,
* ctrl+enter, workbench.action.chat.insertCodeBlock, when: accessibleViewInCodeBlock && chatIsEnabled || chatIsEnabled && inChat && !inChatInput,
* ctrl+enter, workbench.action.chat.openSessionInEditorGroup, when: agentSessionsViewerFocused && !isSessionsWindow,
* ctrl+enter, workbench.action.chat.submitWithCodebase, when: chatInputHasText && inChatInput && !chatSessionRequestInProgress,
* ctrl+enter, workbench.action.terminal.chat.runCommand, when: chatIsEnabled && terminalChatResponseContainsCodeBlock && terminalHasBeenCreated && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks || chatIsEnabled && terminalChatResponseContainsCodeBlock && terminalProcessSupported && !terminalChatActiveRequest && !terminalChatResponseContainsMultipleCodeBlocks,
* ctrl+enter, workbench.action.terminal.chat.runFirstCommand, when: chatIsEnabled && terminalChatResponseContainsMultipleCodeBlocks && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && terminalChatResponseContainsMultipleCodeBlocks && terminalProcessSupported && !terminalChatActiveRequest,
* ctrl+escape, kb-macro.wrap, when: false, args: {"command":"workbench.action.chat.cancel"},
* ctrl+escape, kb-macro.wrap, when: false, args: {"command":"workbench.action.hideComment"},
* ctrl+escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* ctrl+escape, quickInput.hide, when: inQuickInput,
* ctrl+f, actions.find, when: editorFocus || editorIsOpen,
* ctrl+f, commentsFocusFilter, when: focusedView == 'workbench.panel.comments',
* ctrl+f, editor.action.extensioneditor.showfind, when: !editorFocus && activeEditor == 'workbench.editor.extension',
* ctrl+f, editor.action.webvieweditor.showFind, when: webviewFindWidgetEnabled && !editorFocus && activeEditor == 'WebviewEditor',
* ctrl+f, kb-macro.wrap, when: browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.showFind"},
* ctrl+f, kb-macro.wrap, when: editorFocus && kb-macro.active || editorIsOpen && kb-macro.active, args: {"command":"actions.find"},
* ctrl+f, kb-macro.wrap, when: false, args: {"command":"cursorRight"},
* ctrl+f, kb-macro.wrap, when: inDebugRepl && kb-macro.active && textInputFocus, args: {"command":"repl.action.filter"},
* ctrl+f, kb-macro.wrap, when: inKeybindings && kb-macro.active, args: {"command":"keybindings.editor.searchKeybindings"},
* ctrl+f, kb-macro.wrap, when: inSettingsEditor && kb-macro.active, args: {"command":"settings.action.search"},
* ctrl+f, kb-macro.wrap, when: kb-macro.active && !editorFocus && activeEditor == 'workbench.editor.extension', args: {"command":"editor.action.extensioneditor.showfind"},
* ctrl+f, kb-macro.wrap, when: kb-macro.active && focusedView == 'workbench.panel.comments', args: {"command":"commentsFocusFilter"},
* ctrl+f, kb-macro.wrap, when: kb-macro.active && focusedView == 'workbench.panel.markers.view', args: {"command":"problems.action.focusFilter"},
* ctrl+f, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !editorFocus && activeEditor == 'workbench.editor.interactive' || kb-macro.active && notebookEditorFocused && !editorFocus && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.find"},
* ctrl+f, kb-macro.wrap, when: kb-macro.active && terminalFindFocused && terminalHasBeenCreated || kb-macro.active && terminalFindFocused && terminalProcessSupported || kb-macro.active && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.focusFind"},
* ctrl+f, kb-macro.wrap, when: kb-macro.active && webviewFindWidgetEnabled && !editorFocus && activeEditor == 'WebviewEditor', args: {"command":"editor.action.webvieweditor.showFind"},
* ctrl+f, keybindings.editor.searchKeybindings, when: inKeybindings,
* ctrl+f, notebook.find, when: notebookEditorFocused && !editorFocus && activeEditor == 'workbench.editor.interactive' || notebookEditorFocused && !editorFocus && activeEditor == 'workbench.editor.notebook',
* ctrl+f, problems.action.focusFilter, when: focusedView == 'workbench.panel.markers.view',
* ctrl+f, repl.action.filter, when: inDebugRepl && textInputFocus,
* ctrl+f, settings.action.search, when: inSettingsEditor,
* ctrl+f, workbench.action.browser.showFind, when: browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+f, workbench.action.terminal.focusFind, when: terminalFindFocused && terminalHasBeenCreated || terminalFindFocused && terminalProcessSupported || terminalFocusInAny && terminalHasBeenCreated || terminalFocusInAny && terminalProcessSupported,
* ctrl+f2, editor.action.changeAll, when: editorTextFocus && !editorReadonly,
* ctrl+f2, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.changeAll"},
* ctrl+f3, editor.action.nextSelectionMatchFindAction, when: editorFocus,
* ctrl+f3, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.nextSelectionMatchFindAction"},
* ctrl+f4, kb-macro.wrap, when: activeEditorGroupEmpty && kb-macro.active && multipleEditorGroups, args: {"command":"workbench.action.closeGroup"},
* ctrl+f4, kb-macro.wrap, when: auxiliaryBarMaximized && kb-macro.active, args: {"command":"workbench.action.restoreAuxiliaryBar"},
* ctrl+f4, kb-macro.wrap, when: kb-macro.active && terminalEditorFocus && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalEditorFocus && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.killEditor"},
* ctrl+f4, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeActiveEditor"},
* ctrl+f4, workbench.action.closeActiveEditor,
* ctrl+f4, workbench.action.closeGroup, when: activeEditorGroupEmpty && multipleEditorGroups,
* ctrl+f4, workbench.action.restoreAuxiliaryBar, when: auxiliaryBarMaximized,
* ctrl+f4, workbench.action.terminal.killEditor, when: terminalEditorFocus && terminalFocus && terminalHasBeenCreated || terminalEditorFocus && terminalFocus && terminalProcessSupported,
* ctrl+f5, debug.openView, when: !debuggersAvailable,
* ctrl+f5, kb-macro.wrap, when: browserFocused && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.hardReload"},
* ctrl+f5, kb-macro.wrap, when: debuggersAvailable && kb-macro.active && debugState != 'initializing', args: {"command":"workbench.action.debug.run"},
* ctrl+f5, kb-macro.wrap, when: kb-macro.active && !debuggersAvailable, args: {"command":"debug.openView"},
* ctrl+f5, workbench.action.browser.hardReload, when: browserFocused && activeEditor == 'workbench.editor.browser',
* ctrl+f5, workbench.action.debug.run, when: debuggersAvailable && debugState != 'initializing',
* ctrl+f9, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active, args: {"command":"workbench.action.chat.nextFileTree"},
* ctrl+f9, workbench.action.chat.nextFileTree, when: chatIsEnabled && inChat,
* ctrl+f11, kb-macro.wrap, when: inDebugMode && kb-macro.active && stepIntoTargetsSupported && debugState == 'stopped', args: {"command":"workbench.action.debug.stepIntoTarget"},
* ctrl+f11, workbench.action.debug.stepIntoTarget, when: inDebugMode && stepIntoTargetsSupported && debugState == 'stopped',
* ctrl+f12, editor.action.goToImplementation, when: editorHasImplementationProvider && editorTextFocus,
* ctrl+f12, editor.action.revealDefinition, when: editorHasDefinitionProvider && editorTextFocus && isWeb,
* ctrl+f12, kb-macro.wrap, when: editorHasImplementationProvider && editorTextFocus && kb-macro.active, args: {"command":"editor.action.goToImplementation"},
* ctrl+f12, kb-macro.wrap, when: false, args: {"command":"editor.action.revealDefinition"},
* ctrl+g, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.goToRecentDirectory"},
* ctrl+g, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.gotoLine"},
* ctrl+g, workbench.action.gotoLine,
* ctrl+g, workbench.action.terminal.goToRecentDirectory, when: terminalFocus && terminalHasBeenCreated || terminalFocus && terminalProcessSupported,
* ctrl+h, editor.action.startFindReplaceAction, when: editorFocus || editorIsOpen,
* ctrl+h, kb-macro.wrap, when: editorFocus && kb-macro.active || editorIsOpen && kb-macro.active, args: {"command":"editor.action.startFindReplaceAction"},
* ctrl+h, kb-macro.wrap, when: false, args: {"command":"deleteLeft"},
* ctrl+home, cursorTop, when: textInputFocus,
* ctrl+home, interactive.scrollToTop, when: activeEditor == 'workbench.editor.interactive',
* ctrl+home, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.scrollToTopAccessibleView"},
* ctrl+home, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.first"},
* ctrl+home, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.interactive', args: {"command":"interactive.scrollToTop"},
* ctrl+home, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.focusTop"},
* ctrl+home, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollToTop"},
* ctrl+home, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorTop"},
* ctrl+home, notebook.focusTop, when: notebookEditorFocused && !inputFocus,
* ctrl+home, quickInput.first, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+home, workbench.action.terminal.scrollToTop, when: terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
* ctrl+home, workbench.action.terminal.scrollToTopAccessibleView, when: accessibleViewIsShown && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
* ctrl+i, editor.action.triggerSuggest, when: editorHasCompletionItemProvider && textInputFocus && !editorReadonly && !suggestWidgetVisible,
* ctrl+i, focusSuggestion, when: suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* ctrl+i, inlineChat.askInChat, when: config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasEditsAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook',
* ctrl+i, inlineChat.start, when: editorFocus && inlineChatHasEditsAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook',
* ctrl+i, kb-macro.wrap, when: aiSettingResultsAvailable && inSettingsEditor && kb-macro.active, args: {"command":"settings.action.toggleAiSearch"},
* ctrl+i, kb-macro.wrap, when: chatIsEnabled && hasSpeechProvider && inChatInput && kb-macro.active && !editorFocus && !notebookEditorFocused && !scopedVoiceChatGettingReady && !speechToTextInProgress || chatIsEnabled && hasSpeechProvider && inlineChatFocused && kb-macro.active && !editorFocus && !notebookEditorFocused && !scopedVoiceChatGettingReady && !speechToTextInProgress, args: {"command":"workbench.action.chat.startVoiceChat"},
* ctrl+i, kb-macro.wrap, when: chatIsEnabled && hasSpeechProvider && kb-macro.active && !chatSessionRequestInProgress && !editorFocus && !inChatInput && !inSettingsEditor && !inlineChatFocused && !notebookEditorFocused && !searchViewletFocus, args: {"command":"workbench.action.chat.holdToVoiceChatInChatView"},
* ctrl+i, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatAgentRegistered && terminalFocusInAny && terminalHasBeenCreated || chatIsEnabled && kb-macro.active && terminalChatAgentRegistered && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.chat.start"},
* ctrl+i, kb-macro.wrap, when: config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || config.inlineChat.askInChat && editorFocus && inlineChatFileBelongsToChat && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat.askInChat"},
* ctrl+i, kb-macro.wrap, when: config.notebook.experimental.cellChat && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus || config.notebook.experimental.generate && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.chat.start"},
* ctrl+i, kb-macro.wrap, when: editorFocus && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasEditsAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookAgent && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasNotebookAgent && inlineChatHasNotebookInline && inlineChatPossible && kb-macro.active && !config.inlineChat.askInChat && !editorReadonly && !editorSimpleInput && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat.start"},
* ctrl+i, kb-macro.wrap, when: editorHasCompletionItemProvider && kb-macro.active && textInputFocus && !editorReadonly && !suggestWidgetVisible, args: {"command":"editor.action.triggerSuggest","record":"side-effect"},
* ctrl+i, kb-macro.wrap, when: hasAIResultProviderKey && kb-macro.active && searchViewletFocus, args: {"command":"search.action.searchWithAI"},
* ctrl+i, kb-macro.wrap, when: inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || inChatInput && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'view' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || inlineChatFocused && kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'view', args: {"command":"workbench.action.chat.stopListeningAndSubmit"},
* ctrl+i, kb-macro.wrap, when: kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.suggestToggleDetails"},
* ctrl+i, kb-macro.wrap, when: kb-macro.active && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus, args: {"command":"toggleSuggestionDetails","record":"side-effect"},
* ctrl+i, kb-macro.wrap, when: kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"focusSuggestion","record":"side-effect"},
* ctrl+i, notebook.cell.chat.start, when: config.notebook.experimental.cellChat && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus || config.notebook.experimental.generate && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus,
* ctrl+i, search.action.searchWithAI, when: hasAIResultProviderKey && searchViewletFocus,
* ctrl+i, settings.action.toggleAiSearch, when: aiSettingResultsAvailable && inSettingsEditor,
* ctrl+i, toggleSuggestionDetails, when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* ctrl+i, workbench.action.chat.holdToVoiceChatInChatView, when: chatIsEnabled && hasSpeechProvider && !chatSessionRequestInProgress && !editorFocus && !inChatInput && !inSettingsEditor && !inlineChatFocused && !notebookEditorFocused && !searchViewletFocus,
* ctrl+i, workbench.action.chat.startVoiceChat, when: chatIsEnabled && hasSpeechProvider && inChatInput && !editorFocus && !notebookEditorFocused && !scopedVoiceChatGettingReady && !speechToTextInProgress || chatIsEnabled && hasSpeechProvider && inlineChatFocused && !editorFocus && !notebookEditorFocused && !scopedVoiceChatGettingReady && !speechToTextInProgress,
* ctrl+i, workbench.action.chat.stopListeningAndSubmit, when: inChatInput && voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || inChatInput && voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || inChatInput && voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || inChatInput && voiceChatInProgress && scopedVoiceChatInProgress == 'view' || inlineChatFocused && voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || inlineChatFocused && voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || inlineChatFocused && voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || inlineChatFocused && voiceChatInProgress && scopedVoiceChatInProgress == 'view',
* ctrl+i, workbench.action.terminal.chat.start, when: chatIsEnabled && terminalChatAgentRegistered && terminalFocusInAny && terminalHasBeenCreated || chatIsEnabled && terminalChatAgentRegistered && terminalFocusInAny && terminalProcessSupported,
* ctrl+i, workbench.action.terminal.suggestToggleDetails, when: simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* ctrl+insert, editor.action.clipboardCopyAction,
* ctrl+insert, kb-macro.wrap, when: kb-macro.active && suggestWidgetDetailsFocused, args: {"command":"suggestWidgetCopy"},
* ctrl+insert, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.clipboardCopyAction","await":"clipboard"},
* ctrl+insert, suggestWidgetCopy, when: suggestWidgetDetailsFocused,
* ctrl+j, kb-macro.wrap, when: false, args: {"command":"editor.action.joinLines"},
* ctrl+j, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.togglePanel"},
* ctrl+j, workbench.action.togglePanel,
* ctrl+k c, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.files.action.compareWithClipboard"},
* ctrl+k c, workbench.files.action.compareWithClipboard,
* ctrl+k ctrl+,, editor.createFoldingRangeFromSelection, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+,, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.createFoldingRangeFromSelection"},
* ctrl+k ctrl+-, editor.foldAllExcept, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+-, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldAllExcept"},
* ctrl+k ctrl+., editor.removeManualFoldingRanges, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+., kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.removeManualFoldingRanges"},
* ctrl+k ctrl+/, editor.foldAllBlockComments, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+/, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldAllBlockComments"},
* ctrl+k ctrl+0, editor.foldAll, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+0, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldAll"},
* ctrl+k ctrl+1, editor.foldLevel1, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+1, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldLevel1"},
* ctrl+k ctrl+2, editor.foldLevel2, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+2, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldLevel2"},
* ctrl+k ctrl+3, editor.foldLevel3, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+3, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldLevel3"},
* ctrl+k ctrl+4, editor.foldLevel4, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+4, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldLevel4"},
* ctrl+k ctrl+5, editor.foldLevel5, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+5, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldLevel5"},
* ctrl+k ctrl+6, editor.foldLevel6, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+6, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldLevel6"},
* ctrl+k ctrl+7, editor.foldLevel7, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+7, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldLevel7"},
* ctrl+k ctrl+8, editor.foldAllMarkerRegions, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+8, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldAllMarkerRegions"},
* ctrl+k ctrl+9, editor.unfoldAllMarkerRegions, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+9, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.unfoldAllMarkerRegions"},
* ctrl+k ctrl+=, editor.unfoldAllExcept, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+=, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.unfoldAllExcept"},
* ctrl+k ctrl+[, editor.foldRecursively, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+[, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.foldRecursively"},
* ctrl+k ctrl+\\, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.splitEditorDown"},
* ctrl+k ctrl+\\, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.splitEditorLeft"},
* ctrl+k ctrl+\\, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.splitEditorOrthogonal"},
* ctrl+k ctrl+\\, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.splitEditorRight"},
* ctrl+k ctrl+\\, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.splitEditorUp"},
* ctrl+k ctrl+\\, workbench.action.splitEditorDown,
* ctrl+k ctrl+\\, workbench.action.splitEditorLeft,
* ctrl+k ctrl+\\, workbench.action.splitEditorOrthogonal,
* ctrl+k ctrl+\\, workbench.action.splitEditorRight,
* ctrl+k ctrl+\\, workbench.action.splitEditorUp,
* ctrl+k ctrl+], editor.unfoldRecursively, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+], kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.unfoldRecursively"},
* ctrl+k ctrl+a, kb-macro.wrap, when: inKeybindings && kb-macro.active && keybindingFocus, args: {"command":"keybindings.editor.addKeybinding"},
* ctrl+k ctrl+a, keybindings.editor.addKeybinding, when: inKeybindings && keybindingFocus,
* ctrl+k ctrl+alt+c, kb-macro.wrap, when: activeCursorHasCommentingRange && kb-macro.active, args: {"command":"workbench.action.addComment"},
* ctrl+k ctrl+alt+c, kb-macro.wrap, when: false, args: {"command":"copyFilePath"},
* ctrl+k ctrl+alt+c, workbench.action.addComment, when: activeCursorHasCommentingRange,
* ctrl+k ctrl+alt+down, editor.action.nextCommentingRange, when: accessibilityModeEnabled && commentFocused || accessibilityModeEnabled && editorFocus || accessibilityHelpIsShown && accessibilityModeEnabled && accessibleViewCurrentProviderId == 'comments',
* ctrl+k ctrl+alt+down, kb-macro.wrap, when: accessibilityModeEnabled && commentFocused && kb-macro.active || accessibilityModeEnabled && editorFocus && kb-macro.active || accessibilityHelpIsShown && accessibilityModeEnabled && kb-macro.active && accessibleViewCurrentProviderId == 'comments', args: {"command":"editor.action.nextCommentingRange"},
* ctrl+k ctrl+alt+s, git.stageSelectedRanges, when: editorTextFocus && !operationInProgress && resourceScheme == 'file',
* ctrl+k ctrl+alt+s, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !operationInProgress && resourceScheme == 'file', args: {"command":"git.stageSelectedRanges"},
* ctrl+k ctrl+alt+up, editor.action.previousCommentingRange, when: accessibilityModeEnabled && commentFocused || accessibilityModeEnabled && editorFocus || accessibilityHelpIsShown && accessibilityModeEnabled && accessibleViewCurrentProviderId == 'comments',
* ctrl+k ctrl+alt+up, kb-macro.wrap, when: accessibilityModeEnabled && commentFocused && kb-macro.active || accessibilityModeEnabled && editorFocus && kb-macro.active || accessibilityHelpIsShown && accessibilityModeEnabled && kb-macro.active && accessibleViewCurrentProviderId == 'comments', args: {"command":"editor.action.previousCommentingRange"},
* ctrl+k ctrl+b, editor.action.setSelectionAnchor, when: editorTextFocus,
* ctrl+k ctrl+b, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.setSelectionAnchor"},
* ctrl+k ctrl+c, editor.action.addCommentLine, when: editorTextFocus && !editorReadonly,
* ctrl+k ctrl+c, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.addCommentLine"},
* ctrl+k ctrl+c, kb-macro.wrap, when: kb-macro.active && notebookCellInputIsCollapsed && notebookCellListFocused, args: {"command":"notebook.cell.expandCellInput"},
* ctrl+k ctrl+c, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && !inputFocus && !notebookCellInputIsCollapsed, args: {"command":"notebook.cell.collapseCellInput"},
* ctrl+k ctrl+c, notebook.cell.collapseCellInput, when: notebookCellListFocused && !inputFocus && !notebookCellInputIsCollapsed,
* ctrl+k ctrl+c, notebook.cell.expandCellInput, when: notebookCellInputIsCollapsed && notebookCellListFocused,
* ctrl+k ctrl+d, editor.action.moveSelectionToNextFindMatch, when: editorFocus,
* ctrl+k ctrl+d, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.moveSelectionToNextFindMatch"},
* ctrl+k ctrl+down, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusBelowGroup"},
* ctrl+k ctrl+down, workbench.action.focusBelowGroup,
* ctrl+k ctrl+e, kb-macro.wrap, when: inKeybindings && kb-macro.active && keybindingFocus, args: {"command":"keybindings.editor.defineWhenExpression"},
* ctrl+k ctrl+e, keybindings.editor.defineWhenExpression, when: inKeybindings && keybindingFocus,
* ctrl+k ctrl+f, editor.action.formatSelection, when: editorHasDocumentSelectionFormattingProvider && editorTextFocus && !editorReadonly,
* ctrl+k ctrl+f, kb-macro.wrap, when: editorHasDocumentSelectionFormattingProvider && editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.formatSelection"},
* ctrl+k ctrl+f12, editor.action.revealDefinitionAside, when: editorHasDefinitionProvider && editorTextFocus && isWeb && !isInEmbeddedEditor,
* ctrl+k ctrl+f12, kb-macro.wrap, when: false, args: {"command":"editor.action.revealDefinitionAside"},
* ctrl+k ctrl+h, kb-macro.wrap, when: false, args: {"command":"workbench.action.output.toggleOutput"},
* ctrl+k ctrl+i, editor.action.showHover, when: editorTextFocus,
* ctrl+k ctrl+i, editor.debug.action.showDebugHover, when: editorTextFocus && inDebugMode,
* ctrl+k ctrl+i, kb-macro.wrap, when: editorTextFocus && inDebugMode && kb-macro.active, args: {"command":"editor.debug.action.showDebugHover"},
* ctrl+k ctrl+i, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.showHover"},
* ctrl+k ctrl+i, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.showHover"},
* ctrl+k ctrl+i, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalIsOpen || kb-macro.active && terminalFocus && terminalProcessSupported || kb-macro.active && terminalHasBeenCreated && terminalTabsFocus || kb-macro.active && terminalIsOpen && terminalTabsFocus || kb-macro.active && terminalProcessSupported && terminalTabsFocus, args: {"command":"workbench.action.terminal.focusHover"},
* ctrl+k ctrl+i, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.showHover"},
* ctrl+k ctrl+i, list.showHover, when: listFocus && !inputFocus && !treestickyScrollFocused,
* ctrl+k ctrl+i, workbench.action.showHover,
* ctrl+k ctrl+i, workbench.action.terminal.focusHover, when: terminalFocus && terminalHasBeenCreated || terminalFocus && terminalIsOpen || terminalFocus && terminalProcessSupported || terminalHasBeenCreated && terminalTabsFocus || terminalIsOpen && terminalTabsFocus || terminalProcessSupported && terminalTabsFocus,
* ctrl+k ctrl+j, editor.unfoldAll, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+j, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.unfoldAll"},
* ctrl+k ctrl+k, editor.action.defineKeybinding, when: resource == 'vscode-userdata:/c%3A/Users/synag/AppData/Roaming/Code/User/keybindings.json',
* ctrl+k ctrl+k, editor.action.selectFromAnchorToCursor, when: editorTextFocus && selectionAnchorSet,
* ctrl+k ctrl+k, kb-macro.wrap, when: editorTextFocus && kb-macro.active && selectionAnchorSet, args: {"command":"editor.action.selectFromAnchorToCursor"},
* ctrl+k ctrl+k, kb-macro.wrap, when: false, args: {"command":"editor.action.defineKeybinding"},
* ctrl+k ctrl+k, kb-macro.wrap, when: kb-macro.active && resource == 'vscode-userdata:/d%3A/a/vscode-kb-macro/vscode-kb-macro/empty2/User/keybindings.json', args: {"command":"editor.action.defineKeybinding"},
* ctrl+k ctrl+l, editor.toggleFold, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+l, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.toggleFold"},
* ctrl+k ctrl+left, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusLeftGroup"},
* ctrl+k ctrl+left, workbench.action.focusLeftGroup,
* ctrl+k ctrl+m, kb-macro.wrap, when: editorPartMaximizedEditorGroup && kb-macro.active || editorPartMultipleEditorGroups && kb-macro.active, args: {"command":"workbench.action.toggleMaximizeEditorGroup"},
* ctrl+k ctrl+m, workbench.action.toggleMaximizeEditorGroup, when: editorPartMaximizedEditorGroup || editorPartMultipleEditorGroups,
* ctrl+k ctrl+n, git.unstageSelectedRanges, when: editorTextFocus && isInDiffEditor && isInDiffRightEditor && !operationInProgress && resourceScheme == 'git',
* ctrl+k ctrl+n, kb-macro.wrap, when: editorTextFocus && isInDiffEditor && isInDiffRightEditor && kb-macro.active && !operationInProgress && resourceScheme == 'git', args: {"command":"git.unstageSelectedRanges"},
* ctrl+k ctrl+o, kb-macro.wrap, when: kb-macro.active && openFolderWorkspaceSupport, args: {"command":"workbench.action.files.openFolder"},
* ctrl+k ctrl+o, kb-macro.wrap, when: kb-macro.active && remoteFileDialogVisible, args: {"command":"workbench.action.files.openLocalFolder"},
* ctrl+k ctrl+o, workbench.action.files.openFolder, when: openFolderWorkspaceSupport,
* ctrl+k ctrl+o, workbench.action.files.openLocalFolder, when: remoteFileDialogVisible,
* ctrl+k ctrl+p, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.showAllEditors"},
* ctrl+k ctrl+p, workbench.action.showAllEditors,
* ctrl+k ctrl+pagedown, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.nextEditorInGroup"},
* ctrl+k ctrl+pagedown, workbench.action.nextEditorInGroup,
* ctrl+k ctrl+pageup, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.previousEditorInGroup"},
* ctrl+k ctrl+pageup, workbench.action.previousEditorInGroup,
* ctrl+k ctrl+q, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.navigateToLastEditLocation"},
* ctrl+k ctrl+q, workbench.action.navigateToLastEditLocation,
* ctrl+k ctrl+r, git.revertSelectedRanges, when: editorTextFocus && !operationInProgress && resourceScheme == 'file',
* ctrl+k ctrl+r, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !operationInProgress && resourceScheme == 'file', args: {"command":"git.revertSelectedRanges"},
* ctrl+k ctrl+r, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.keybindingsReference"},
* ctrl+k ctrl+r, workbench.action.keybindingsReference,
* ctrl+k ctrl+right, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusRightGroup"},
* ctrl+k ctrl+right, workbench.action.focusRightGroup,
* ctrl+k ctrl+s, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openGlobalKeybindings"},
* ctrl+k ctrl+s, workbench.action.openGlobalKeybindings,
* ctrl+k ctrl+shift+\\, kb-macro.wrap, when: activeEditorCanSplitInGroup && kb-macro.active, args: {"command":"workbench.action.splitEditorInGroup"},
* ctrl+k ctrl+shift+\\, kb-macro.wrap, when: editorTextFocus && kb-macro.active && notebookCellEditable && notebookEditable && notebookEditorFocused, args: {"command":"notebook.cell.split"},
* ctrl+k ctrl+shift+\\, kb-macro.wrap, when: kb-macro.active && sideBySideEditorActive, args: {"command":"workbench.action.joinEditorInGroup"},
* ctrl+k ctrl+shift+\\, notebook.cell.split, when: editorTextFocus && notebookCellEditable && notebookEditable && notebookEditorFocused,
* ctrl+k ctrl+shift+\\, workbench.action.joinEditorInGroup, when: sideBySideEditorActive,
* ctrl+k ctrl+shift+\\, workbench.action.splitEditorInGroup, when: activeEditorCanSplitInGroup,
* ctrl+k ctrl+shift+alt+c, kb-macro.wrap, when: false, args: {"command":"copyRelativeFilePath"},
* ctrl+k ctrl+shift+c, copyRelativeFilePath, when: !editorFocus,
* ctrl+k ctrl+shift+c, copyRelativeFilePath, when: editorFocus,
* ctrl+k ctrl+shift+c, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"copyRelativeFilePath"},
* ctrl+k ctrl+shift+c, kb-macro.wrap, when: kb-macro.active && !editorFocus, args: {"command":"copyRelativeFilePath"},
* ctrl+k ctrl+shift+l, editor.toggleFoldRecursively, when: editorTextFocus && foldingEnabled,
* ctrl+k ctrl+shift+l, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.toggleFoldRecursively"},
* ctrl+k ctrl+shift+n, kb-macro.wrap, when: kb-macro.active, args: {"command":"notifications.showList"},
* ctrl+k ctrl+shift+n, notifications.showList,
* ctrl+k ctrl+shift+s, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.saveWithoutFormatting"},
* ctrl+k ctrl+shift+s, workbench.action.files.saveWithoutFormatting,
* ctrl+k ctrl+shift+w, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeAllGroups"},
* ctrl+k ctrl+shift+w, workbench.action.closeAllGroups,
* ctrl+k ctrl+t, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.selectTheme"},
* ctrl+k ctrl+t, workbench.action.selectTheme,
* ctrl+k ctrl+u, editor.action.removeCommentLine, when: editorTextFocus && !editorReadonly,
* ctrl+k ctrl+u, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.removeCommentLine"},
* ctrl+k ctrl+up, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusAboveGroup"},
* ctrl+k ctrl+up, workbench.action.focusAboveGroup,
* ctrl+k ctrl+w, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeAllEditors"},
* ctrl+k ctrl+w, workbench.action.closeAllEditors,
* ctrl+k ctrl+x, editor.action.trimTrailingWhitespace, when: editorTextFocus && !editorReadonly,
* ctrl+k ctrl+x, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.trimTrailingWhitespace"},
* ctrl+k d, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.files.action.compareWithSaved"},
* ctrl+k d, workbench.files.action.compareWithSaved,
* ctrl+k down, kb-macro.wrap, when: kb-macro.active && focusedView != '', args: {"command":"views.moveViewDown"},
* ctrl+k down, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveActiveEditorGroupDown"},
* ctrl+k down, views.moveViewDown, when: focusedView != '',
* ctrl+k down, workbench.action.moveActiveEditorGroupDown,
* ctrl+k e, kb-macro.wrap, when: kb-macro.active && workbench.explorer.openEditorsView.active, args: {"command":"workbench.files.action.focusOpenEditorsView"},
* ctrl+k e, workbench.files.action.focusOpenEditorsView, when: workbench.explorer.openEditorsView.active,
* ctrl+k enter, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.keepEditor"},
* ctrl+k enter, workbench.action.keepEditor,
* ctrl+k f, kb-macro.wrap, when: emptyWorkspaceSupport && kb-macro.active && workbenchState != 'empty', args: {"command":"workbench.action.closeFolder"},
* ctrl+k f, workbench.action.closeFolder, when: emptyWorkspaceSupport && workbenchState != 'empty',
* ctrl+k f2, kb-macro.wrap, when: dirtyDiffVisible && kb-macro.active, args: {"command":"toggleQuickDiffWidgetFocus"},
* ctrl+k f2, kb-macro.wrap, when: inReferenceSearchEditor && kb-macro.active || kb-macro.active && referenceSearchVisible, args: {"command":"togglePeekWidgetFocus"},
* ctrl+k f2, togglePeekWidgetFocus, when: inReferenceSearchEditor || referenceSearchVisible,
* ctrl+k f2, toggleQuickDiffWidgetFocus, when: dirtyDiffVisible,
* ctrl+k f12, editor.action.revealDefinitionAside, when: editorHasDefinitionProvider && editorTextFocus && !isInEmbeddedEditor,
* ctrl+k f12, kb-macro.wrap, when: editorHasDefinitionProvider && editorTextFocus && kb-macro.active && !isInEmbeddedEditor, args: {"command":"editor.action.revealDefinitionAside"},
* ctrl+k i, kb-macro.wrap, when: config.notebook.experimental.cellChat && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus || config.notebook.experimental.generate && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.chat.start"},
* ctrl+k i, notebook.cell.chat.start, when: config.notebook.experimental.cellChat && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus || config.notebook.experimental.generate && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus,
* ctrl+k left, kb-macro.wrap, when: kb-macro.active && focusedView != '', args: {"command":"views.moveViewLeft"},
* ctrl+k left, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveActiveEditorGroupLeft"},
* ctrl+k left, views.moveViewLeft, when: focusedView != '',
* ctrl+k left, workbench.action.moveActiveEditorGroupLeft,
* ctrl+k m, kb-macro.wrap, when: kb-macro.active && !notebookEditorFocused, args: {"command":"workbench.action.editor.changeLanguageMode"},
* ctrl+k m, kb-macro.wrap, when: kb-macro.active && notebookCellEditable && notebookEditable && notebookEditorFocused, args: {"command":"notebook.cell.changeLanguage"},
* ctrl+k m, notebook.cell.changeLanguage, when: notebookCellEditable && notebookEditable && notebookEditorFocused,
* ctrl+k m, workbench.action.editor.changeLanguageMode, when: !notebookEditorFocused,
* ctrl+k o, kb-macro.wrap, when: activeEditor && kb-macro.active, args: {"command":"workbench.action.copyEditorToNewWindow"},
* ctrl+k o, workbench.action.copyEditorToNewWindow, when: activeEditor,
* ctrl+k p, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.copyPathOfActiveFile"},
* ctrl+k p, workbench.action.files.copyPathOfActiveFile,
* ctrl+k r, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.revealActiveFileInWindows"},
* ctrl+k r, workbench.action.files.revealActiveFileInWindows,
* ctrl+k right, kb-macro.wrap, when: kb-macro.active && focusedView != '', args: {"command":"views.moveViewRight"},
* ctrl+k right, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveActiveEditorGroupRight"},
* ctrl+k right, views.moveViewRight, when: focusedView != '',
* ctrl+k right, workbench.action.moveActiveEditorGroupRight,
* ctrl+k s, kb-macro.wrap, when: false, args: {"command":"workbench.action.files.saveWithoutFormatting"},
* ctrl+k s, kb-macro.wrap, when: kb-macro.active, args: {"command":"saveAll"},
* ctrl+k s, saveAll,
* ctrl+k shift+enter, kb-macro.wrap, when: activeEditorIsPinned && kb-macro.active, args: {"command":"workbench.action.unpinEditor"},
* ctrl+k shift+enter, kb-macro.wrap, when: kb-macro.active && !activeEditorIsPinned, args: {"command":"workbench.action.pinEditor"},
* ctrl+k shift+enter, workbench.action.pinEditor, when: !activeEditorIsPinned,
* ctrl+k shift+enter, workbench.action.unpinEditor, when: activeEditorIsPinned,
* ctrl+k shift+o, kb-macro.wrap, when: inDiffEditor && kb-macro.active, args: {"command":"workbench.action.compareEditor.openSide"},
* ctrl+k shift+o, workbench.action.compareEditor.openSide, when: inDiffEditor,
* ctrl+k t, kb-macro.wrap, when: kb-macro.active && notebookCellHasOutputs && notebookCellListFocused && !inputFocus && !notebookCellOutputIsCollapsed, args: {"command":"notebook.cell.collapseCellOutput"},
* ctrl+k t, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && notebookCellOutputIsCollapsed, args: {"command":"notebook.cell.expandCellOutput"},
* ctrl+k t, notebook.cell.collapseCellOutput, when: notebookCellHasOutputs && notebookCellListFocused && !inputFocus && !notebookCellOutputIsCollapsed,
* ctrl+k t, notebook.cell.expandCellOutput, when: notebookCellListFocused && notebookCellOutputIsCollapsed,
* ctrl+k u, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeUnmodifiedEditors"},
* ctrl+k u, workbench.action.closeUnmodifiedEditors,
* ctrl+k up, kb-macro.wrap, when: kb-macro.active && focusedView != '', args: {"command":"views.moveViewUp"},
* ctrl+k up, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveActiveEditorGroupUp"},
* ctrl+k up, views.moveViewUp, when: focusedView != '',
* ctrl+k up, workbench.action.moveActiveEditorGroupUp,
* ctrl+k v, kb-macro.wrap, when: kb-macro.active && !notebookEditorFocused && editorLangId =~ /^(markdown|prompt|instructions|chatagent|skill)$/, args: {"command":"markdown.showPreviewToSide"},
* ctrl+k v, markdown.showPreviewToSide, when: !notebookEditorFocused && editorLangId =~ /^(markdown|prompt|instructions|chatagent|skill)$/,
* ctrl+k w, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeEditorsInGroup"},
* ctrl+k w, workbench.action.closeEditorsInGroup,
* ctrl+k y, kb-macro.wrap, when: kb-macro.active && notebookCellHasOutputs && notebookCellListFocused && !inputFocus, args: {"command":"notebook.cell.toggleOutputScrolling"},
* ctrl+k y, notebook.cell.toggleOutputScrolling, when: notebookCellHasOutputs && notebookCellListFocused && !inputFocus,
* ctrl+k z, kb-macro.wrap, when: kb-macro.active && !isAuxiliaryWindowFocusedContext, args: {"command":"workbench.action.toggleZenMode"},
* ctrl+k z, workbench.action.toggleZenMode, when: !isAuxiliaryWindowFocusedContext,
* ctrl+k, kb-macro.wrap, when: false, args: {"command":"deleteAllRight"},
* ctrl+l, expandLineSelection, when: textInputFocus,
* ctrl+l, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active && chatLocation == 'panel', args: {"command":"workbench.action.chat.newChat"},
* ctrl+l, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.focusUrlInput"},
* ctrl+l, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused, args: {"command":"notebook.centerActiveCell"},
* ctrl+l, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"expandLineSelection"},
* ctrl+l, notebook.centerActiveCell, when: notebookEditorFocused,
* ctrl+l, workbench.action.browser.focusUrlInput, when: activeEditor == 'workbench.editor.browser',
* ctrl+l, workbench.action.chat.newChat, when: chatIsEnabled && inChat && chatLocation == 'panel',
* ctrl+left, breadcrumbs.focusPrevious, when: breadcrumbsActive && breadcrumbsVisible,
* ctrl+left, breadcrumbs.focusPreviousWithPicker, when: breadcrumbsActive && breadcrumbsVisible && listFocus && !inputFocus && !treestickyScrollFocused,
* ctrl+left, cursorWordAccessibilityLeft, when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* ctrl+left, cursorWordLeft, when: textInputFocus && !accessibilityModeEnabled,
* ctrl+left, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && textInputFocus && focusedView == 'workbench.panel.output', args: {"command":"cursorWordAccessibilityLeft"},
* ctrl+left, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"breadcrumbs.focusPreviousWithPicker"},
* ctrl+left, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.focusPrevious"},
* ctrl+left, kb-macro.wrap, when: false, args: {"command":"cursorWordLeft"},
* ctrl+left, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.collapseAll"},
* ctrl+left, kb-macro.wrap, when: kb-macro.active && textInputFocus && !accessibilityModeEnabled, args: {"command":"cursorWordLeft"},
* ctrl+left, list.collapseAll, when: listFocus && !inputFocus && !treestickyScrollFocused,
* ctrl+m, editor.action.toggleTabFocusMode,
* ctrl+m, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.toggleTabFocusMode"},
* ctrl+n, chatEditor.action.undoHunk, when: chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && notebookCellListFocused && !chatEdits.isCurrentlyBeingModified,
* ctrl+n, kb-macro.wrap, when: chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && editorFocus && kb-macro.active && !chatEdits.isCurrentlyBeingModified || chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && kb-macro.active && notebookCellListFocused && !chatEdits.isCurrentlyBeingModified, args: {"command":"chatEditor.action.undoHunk"},
* ctrl+n, kb-macro.wrap, when: chatIsEnabled && inChat && inChatEditor && kb-macro.active, args: {"command":"workbench.action.openChat"},
* ctrl+n, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active && chatLocation == 'panel', args: {"command":"workbench.action.chat.newChat"},
* ctrl+n, kb-macro.wrap, when: false, args: {"command":"cursorDown"},
* ctrl+n, kb-macro.wrap, when: false, args: {"command":"list.focusDown"},
* ctrl+n, kb-macro.wrap, when: false, args: {"command":"selectNextSuggestion","record":"side-effect"},
* ctrl+n, kb-macro.wrap, when: false, args: {"command":"workbench.action.quickOpenSelectNext"},
* ctrl+n, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.newUntitledFile"},
* ctrl+n, selectNextCodeAction, when: false,
* ctrl+n, showNextParameterHint, when: false,
* ctrl+n, workbench.action.chat.newChat, when: chatIsEnabled && inChat && chatLocation == 'panel',
* ctrl+n, workbench.action.files.newUntitledFile,
* ctrl+n, workbench.action.openChat, when: chatIsEnabled && inChat && inChatEditor,
* ctrl+numpad0, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.resetZoom"},
* ctrl+numpad0, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomReset"},
* ctrl+numpad0, workbench.action.browser.resetZoom, when: browserFocused && browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+numpad0, workbench.action.zoomReset,
* ctrl+numpad_add, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.zoomIn"},
* ctrl+numpad_add, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomIn"},
* ctrl+numpad_add, workbench.action.browser.zoomIn, when: browserFocused && browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+numpad_add, workbench.action.zoomIn,
* ctrl+numpad_subtract, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.zoomOut"},
* ctrl+numpad_subtract, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomOut"},
* ctrl+numpad_subtract, workbench.action.browser.zoomOut, when: browserFocused && browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+numpad_subtract, workbench.action.zoomOut,
* ctrl+o, kb-macro.wrap, when: false, args: {"command":"lineBreakInsert"},
* ctrl+o, kb-macro.wrap, when: false, args: {"command":"workbench.action.files.openFileFolder"},
* ctrl+o, kb-macro.wrap, when: kb-macro.active && !openFolderWorkspaceSupport && workbenchState == 'workspace', args: {"command":"workbench.action.files.openFolderViaWorkspace"},
* ctrl+o, kb-macro.wrap, when: kb-macro.active && remoteFileDialogVisible, args: {"command":"workbench.action.files.openLocalFile"},
* ctrl+o, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.openFile"},
* ctrl+o, workbench.action.files.openFile, when: true,
* ctrl+o, workbench.action.files.openFileFolder, when: isMacNative && openFolderWorkspaceSupport,
* ctrl+o, workbench.action.files.openFolderViaWorkspace, when: !openFolderWorkspaceSupport && workbenchState == 'workspace',
* ctrl+o, workbench.action.files.openLocalFile, when: remoteFileDialogVisible,
* ctrl+oem_102, kb-macro.wrap, when: false, args: {"command":"editor.action.inPlaceReplace.up"},
* ctrl+p, kb-macro.wrap, when: false, args: {"command":"cursorUp"},
* ctrl+p, kb-macro.wrap, when: false, args: {"command":"list.focusUp"},
* ctrl+p, kb-macro.wrap, when: false, args: {"command":"selectPrevSuggestion","record":"side-effect"},
* ctrl+p, kb-macro.wrap, when: false, args: {"command":"workbench.action.quickOpenSelectPrevious"},
* ctrl+p, kb-macro.wrap, when: inFilesPicker && inQuickOpen && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigateNextInFilePicker"},
* ctrl+p, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.quickOpen"},
* ctrl+p, selectPrevCodeAction, when: false,
* ctrl+p, showPrevParameterHint, when: false,
* ctrl+p, workbench.action.quickOpen,
* ctrl+p, workbench.action.quickOpenNavigateNextInFilePicker, when: inFilesPicker && inQuickOpen,
* ctrl+pagedown, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && notebookCellEditorFocused, args: {"command":"notebook.focusNextEditor"},
* ctrl+pagedown, kb-macro.wrap, when: false, args: {"command":"scrollLineDown"},
* ctrl+pagedown, kb-macro.wrap, when: inDebugRepl && kb-macro.active, args: {"command":"workbench.action.debug.nextConsole"},
* ctrl+pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* ctrl+pagedown, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectNextPageSuggestion","record":"side-effect"},
* ctrl+pagedown, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !terminalEditorFocus || kb-macro.active && terminalFocus && terminalProcessSupported && !terminalEditorFocus, args: {"command":"workbench.action.terminal.focusNext"},
* ctrl+pagedown, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.nextEditor"},
* ctrl+pagedown, notebook.focusNextEditor, when: accessibilityModeEnabled && notebookCellEditorFocused,
* ctrl+pagedown, quickInput.pageNext, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+pagedown, selectNextPageSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* ctrl+pagedown, workbench.action.debug.nextConsole, when: inDebugRepl,
* ctrl+pagedown, workbench.action.nextEditor,
* ctrl+pagedown, workbench.action.terminal.focusNext, when: terminalFocus && terminalHasBeenCreated && !terminalEditorFocus || terminalFocus && terminalProcessSupported && !terminalEditorFocus,
* ctrl+pageup, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && notebookCellEditorFocused, args: {"command":"notebook.focusPreviousEditor"},
* ctrl+pageup, kb-macro.wrap, when: false, args: {"command":"notebook.focusNextEditor"},
* ctrl+pageup, kb-macro.wrap, when: false, args: {"command":"scrollLineUp"},
* ctrl+pageup, kb-macro.wrap, when: inDebugRepl && kb-macro.active, args: {"command":"workbench.action.debug.prevConsole"},
* ctrl+pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* ctrl+pageup, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectPrevPageSuggestion","record":"side-effect"},
* ctrl+pageup, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !terminalEditorFocus || kb-macro.active && terminalFocus && terminalProcessSupported && !terminalEditorFocus, args: {"command":"workbench.action.terminal.focusPrevious"},
* ctrl+pageup, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.previousEditor"},
* ctrl+pageup, notebook.focusPreviousEditor, when: accessibilityModeEnabled && notebookCellEditorFocused,
* ctrl+pageup, quickInput.pagePrevious, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+pageup, selectPrevPageSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* ctrl+pageup, workbench.action.debug.prevConsole, when: inDebugRepl,
* ctrl+pageup, workbench.action.previousEditor,
* ctrl+pageup, workbench.action.terminal.focusPrevious, when: terminalFocus && terminalHasBeenCreated && !terminalEditorFocus || terminalFocus && terminalProcessSupported && !terminalEditorFocus,
* ctrl+q, kb-macro.wrap, when: false, args: {"command":"workbench.action.quit"},
* ctrl+q, kb-macro.wrap, when: inQuickOpen && inViewsPicker && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigateNextInViewPicker"},
* ctrl+q, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.quickOpenView"},
* ctrl+q, workbench.action.quickOpenNavigateNextInViewPicker, when: inQuickOpen && inViewsPicker,
* ctrl+q, workbench.action.quickOpenView,
* ctrl+r, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalProcessSupported || accessibilityModeEnabled && accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibilityModeEnabled && accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.runRecentCommand"},
* ctrl+r, kb-macro.wrap, when: browserFocused && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.reload"},
* ctrl+r, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatFocus && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatFocus && terminalProcessSupported && !terminalChatActiveRequest, args: {"command":"workbench.action.terminal.chat.rerunRequest"},
* ctrl+r, kb-macro.wrap, when: false, args: {"command":"workbench.action.reloadWindow"},
* ctrl+r, kb-macro.wrap, when: inQuickOpen && inRecentFilesPicker && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigateNextInRecentFilesPicker"},
* ctrl+r, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.openRecent"},
* ctrl+r, workbench.action.browser.reload, when: browserFocused && activeEditor == 'workbench.editor.browser',
* ctrl+r, workbench.action.openRecent,
* ctrl+r, workbench.action.quickOpenNavigateNextInRecentFilesPicker, when: inQuickOpen && inRecentFilesPicker,
* ctrl+r, workbench.action.reloadWindow, when: isDevelopment,
* ctrl+r, workbench.action.terminal.chat.rerunRequest, when: chatIsEnabled && terminalChatFocus && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && terminalChatFocus && terminalProcessSupported && !terminalChatActiveRequest,
* ctrl+r, workbench.action.terminal.runRecentCommand, when: accessibilityModeEnabled && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && terminalFocus && terminalProcessSupported || accessibilityModeEnabled && accessibleViewIsShown && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibilityModeEnabled && accessibleViewIsShown && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal',
* ctrl+right, breadcrumbs.focusNext, when: breadcrumbsActive && breadcrumbsVisible,
* ctrl+right, breadcrumbs.focusNextWithPicker, when: breadcrumbsActive && breadcrumbsVisible && listFocus && !inputFocus && !treestickyScrollFocused,
* ctrl+right, cursorWordAccessibilityRight, when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* ctrl+right, cursorWordEndRight, when: textInputFocus && !accessibilityModeEnabled,
* ctrl+right, editor.action.inlineSuggest.acceptNextWord, when: cursorBeforeGhostText && inlineSuggestionVisible && !accessibilityModeEnabled && !editorReadonly,
* ctrl+right, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && textInputFocus && focusedView == 'workbench.panel.output', args: {"command":"cursorWordAccessibilityRight"},
* ctrl+right, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"breadcrumbs.focusNextWithPicker"},
* ctrl+right, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.focusNext"},
* ctrl+right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* ctrl+right, kb-macro.wrap, when: cursorBeforeGhostText && inlineSuggestionVisible && kb-macro.active && !accessibilityModeEnabled && !editorReadonly, args: {"command":"editor.action.inlineSuggest.acceptNextWord","record":"side-effect"},
* ctrl+right, kb-macro.wrap, when: false, args: {"command":"cursorWordEndRight"},
* ctrl+right, kb-macro.wrap, when: kb-macro.active && textInputFocus && !accessibilityModeEnabled, args: {"command":"cursorWordEndRight"},
* ctrl+right, quickInput.acceptInBackground, when: cursorAtEndOfQuickInputBox && inQuickInput && quickInputType == 'quickPick' || inQuickInput && !inputFocus && quickInputType == 'quickPick',
* ctrl+s, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.save"},
* ctrl+s, workbench.action.files.save,
* ctrl+shift+,, editor.action.inPlaceReplace.up, when: editorTextFocus && !editorReadonly,
* ctrl+shift+,, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.inPlaceReplace.up"},
* ctrl+shift+-, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.zoomOut"},
* ctrl+shift+-, kb-macro.wrap, when: false, args: {"command":"workbench.action.navigateForward"},
* ctrl+shift+-, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomOut"},
* ctrl+shift+-, workbench.action.browser.zoomOut, when: browserFocused && browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+shift+-, workbench.action.zoomOut,
* ctrl+shift+., breadcrumbs.focusAndSelect, when: breadcrumbsPossible && breadcrumbsVisible,
* ctrl+shift+., breadcrumbs.toggleToOn, when: !config.breadcrumbs.enabled,
* ctrl+shift+., editor.action.accessibleViewGoToSymbol, when: accessibilityHelpIsShown && accessibleViewGoToSymbolSupported || accessibleViewGoToSymbolSupported && accessibleViewIsShown,
* ctrl+shift+., editor.action.inPlaceReplace.down, when: editorTextFocus && !editorReadonly,
* ctrl+shift+., github.copilot.chat.copilotCLI.addFileReference, when: editorTextFocus && github.copilot.chat.copilotCLI.hasSession,
* ctrl+shift+., kb-macro.wrap, when: accessibilityHelpIsShown && accessibleViewGoToSymbolSupported && kb-macro.active || accessibleViewGoToSymbolSupported && accessibleViewIsShown && kb-macro.active, args: {"command":"editor.action.accessibleViewGoToSymbol"},
* ctrl+shift+., kb-macro.wrap, when: breadcrumbsPossible && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.focusAndSelect"},
* ctrl+shift+., kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.inPlaceReplace.down"},
* ctrl+shift+., kb-macro.wrap, when: kb-macro.active && !config.breadcrumbs.enabled, args: {"command":"breadcrumbs.toggleToOn"},
* ctrl+shift+/, kb-macro.wrap, when: inChat && kb-macro.active || inChat && inChatTip && kb-macro.active, args: {"command":"workbench.action.chat.focusTip"},
* ctrl+shift+/, workbench.action.chat.focusTip, when: inChat || inChat && inChatTip,
* ctrl+shift+1, editor.action.replaceOne, when: editorFocus && findWidgetVisible,
* ctrl+shift+1, kb-macro.wrap, when: editorFocus && findWidgetVisible && kb-macro.active, args: {"command":"editor.action.replaceOne"},
* ctrl+shift+1, kb-macro.wrap, when: fileMatchFocus && isEditableItem && kb-macro.active && replaceActive && searchViewletVisible, args: {"command":"search.action.replaceAllInFile"},
* ctrl+shift+1, kb-macro.wrap, when: folderMatchFocus && isEditableItem && kb-macro.active && replaceActive && searchViewletVisible, args: {"command":"search.action.replaceAllInFolder"},
* ctrl+shift+1, kb-macro.wrap, when: isEditableItem && kb-macro.active && matchFocus && replaceActive && searchViewletVisible, args: {"command":"search.action.replace"},
* ctrl+shift+1, search.action.replace, when: isEditableItem && matchFocus && replaceActive && searchViewletVisible,
* ctrl+shift+1, search.action.replaceAllInFile, when: fileMatchFocus && isEditableItem && replaceActive && searchViewletVisible,
* ctrl+shift+1, search.action.replaceAllInFolder, when: folderMatchFocus && isEditableItem && replaceActive && searchViewletVisible,
* ctrl+shift+2, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0000"}},
* ctrl+shift+2, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u0000"},
* ctrl+shift+5, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalProcessSupported || kb-macro.active && terminalFocus && terminalWebExtensionContributedProfile, args: {"command":"workbench.action.terminal.split"},
* ctrl+shift+5, kb-macro.wrap, when: kb-macro.active && terminalProcessSupported && terminalTabsFocus, args: {"command":"workbench.action.terminal.splitActiveTab"},
* ctrl+shift+5, workbench.action.terminal.split, when: terminalFocus && terminalProcessSupported || terminalFocus && terminalWebExtensionContributedProfile,
* ctrl+shift+5, workbench.action.terminal.splitActiveTab, when: terminalProcessSupported && terminalTabsFocus,
* ctrl+shift+6, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001e"}},
* ctrl+shift+6, workbench.action.terminal.sendSequence, when: terminalFocus, args: {"text":"\u001e"},
* ctrl+shift+;, breadcrumbs.focus, when: breadcrumbsPossible && breadcrumbsVisible,
* ctrl+shift+;, kb-macro.wrap, when: breadcrumbsPossible && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.focus"},
* ctrl+shift+=, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.zoomIn"},
* ctrl+shift+=, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomIn"},
* ctrl+shift+=, workbench.action.browser.zoomIn, when: browserFocused && browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+shift+=, workbench.action.zoomIn,
* ctrl+shift+[, editor.fold, when: editorTextFocus && foldingEnabled,
* ctrl+shift+[, kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.fold"},
* ctrl+shift+[, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.fold"},
* ctrl+shift+[, notebook.fold, when: notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook',
* ctrl+shift+\\, editor.action.jumpToBracket, when: editorTextFocus,
* ctrl+shift+\\, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.jumpToBracket"},
* ctrl+shift+\\, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported || kb-macro.active && terminalHasBeenCreated && terminalTabsFocus || kb-macro.active && terminalProcessSupported && terminalTabsFocus, args: {"command":"workbench.action.terminal.focusTabs"},
* ctrl+shift+\\, workbench.action.terminal.focusTabs, when: terminalFocus && terminalHasBeenCreated || terminalFocus && terminalProcessSupported || terminalHasBeenCreated && terminalTabsFocus || terminalProcessSupported && terminalTabsFocus,
* ctrl+shift+], editor.unfold, when: editorTextFocus && foldingEnabled,
* ctrl+shift+], kb-macro.wrap, when: editorTextFocus && foldingEnabled && kb-macro.active, args: {"command":"editor.unfold"},
* ctrl+shift+], kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.unfold"},
* ctrl+shift+], notebook.unfold, when: notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook',
* ctrl+shift+`, kb-macro.wrap, when: kb-macro.active && terminalProcessSupported || kb-macro.active && terminalWebExtensionContributedProfile, args: {"command":"workbench.action.terminal.new"},
* ctrl+shift+`, workbench.action.terminal.new, when: terminalProcessSupported || terminalWebExtensionContributedProfile,
* ctrl+shift+a, kb-macro.wrap, when: accessibilityModeEnabled && chatIsEnabled && kb-macro.active && !chatHasQuestionCarousel, args: {"command":"workbench.action.chat.focusConfirmation"},
* ctrl+shift+a, kb-macro.wrap, when: chatHasQuestionCarousel && inChat && kb-macro.active, args: {"command":"workbench.action.chat.focusQuestionCarousel"},
* ctrl+shift+a, kb-macro.wrap, when: false, args: {"command":"cursorLineStartSelect"},
* ctrl+shift+a, kb-macro.wrap, when: false, args: {"command":"editor.action.blockComment"},
* ctrl+shift+a, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.quickOpen"},
* ctrl+shift+a, kb-macro.wrap, when: kb-macro.active && notificationFocus || kb-macro.active && notificationToastsVisible, args: {"command":"notification.acceptPrimaryAction"},
* ctrl+shift+a, notification.acceptPrimaryAction, when: notificationFocus || notificationToastsVisible,
* ctrl+shift+a, workbench.action.browser.quickOpen, when: activeEditor == 'workbench.editor.browser',
* ctrl+shift+a, workbench.action.chat.focusConfirmation, when: accessibilityModeEnabled && chatIsEnabled && !chatHasQuestionCarousel,
* ctrl+shift+a, workbench.action.chat.focusQuestionCarousel, when: chatHasQuestionCarousel && inChat,
* ctrl+shift+a, workbench.view.extension.azure, when: viewContainer.workbench.view.extension.azure.enabled,
* ctrl+shift+alt+`, kb-macro.wrap, when: kb-macro.active && terminalHasBeenCreated || kb-macro.active && terminalProcessSupported, args: {"command":"workbench.action.terminal.newInNewWindow"},
* ctrl+shift+alt+`, workbench.action.terminal.newInNewWindow, when: terminalHasBeenCreated || terminalProcessSupported,
* ctrl+shift+alt+c, kb-macro.wrap, when: false, args: {"command":"copyRelativeFilePath"},
* ctrl+shift+alt+down, cursorColumnSelectDown, when: textInputFocus,
* ctrl+shift+alt+down, kb-macro.wrap, when: false, args: {"command":"editor.action.copyLinesDownAction"},
* ctrl+shift+alt+down, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectDown"},
* ctrl+shift+alt+enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* ctrl+shift+alt+g, editor.action.announceCursorPosition, when: accessibilityModeEnabled && editorTextFocus,
* ctrl+shift+alt+g, kb-macro.wrap, when: accessibilityModeEnabled && editorTextFocus && kb-macro.active, args: {"command":"editor.action.announceCursorPosition"},
* ctrl+shift+alt+i, kb-macro.wrap, when: false, args: {"command":"workbench.action.chat.openagent"},
* ctrl+shift+alt+j, kb-macro.wrap, when: false, args: {"command":"notebook.cell.joinAbove"},
* ctrl+shift+alt+l, kb-macro.wrap, when: chatIsEnabled && kb-macro.active, args: {"command":"workbench.action.quickchat.toggle"},
* ctrl+shift+alt+l, workbench.action.quickchat.toggle, when: chatIsEnabled,
* ctrl+shift+alt+left, cursorColumnSelectLeft, when: textInputFocus,
* ctrl+shift+alt+left, kb-macro.wrap, when: false, args: {"command":"cursorWordPartLeftSelect"},
* ctrl+shift+alt+left, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectLeft"},
* ctrl+shift+alt+o, kb-macro.wrap, when: inChat && kb-macro.active, args: {"command":"workbench.action.terminal.chat.focusMostRecentChatTerminalOutput"},
* ctrl+shift+alt+o, workbench.action.terminal.chat.focusMostRecentChatTerminalOutput, when: inChat,
* ctrl+shift+alt+p, kb-macro.cancelRecording, when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* ctrl+shift+alt+p, kb-macro.playback, when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* ctrl+shift+alt+pagedown, cursorColumnSelectPageDown, when: textInputFocus,
* ctrl+shift+alt+pagedown, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectPageDown"},
* ctrl+shift+alt+pageup, cursorColumnSelectPageUp, when: textInputFocus,
* ctrl+shift+alt+pageup, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectPageUp"},
* ctrl+shift+alt+r, kb-macro.finishRecording, when: kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* ctrl+shift+alt+r, kb-macro.startRecording, when: !kb-macro.recording && config.keyboardMacro.recordingShortcuts == 'Option2',
* ctrl+shift+alt+right, cursorColumnSelectRight, when: textInputFocus,
* ctrl+shift+alt+right, kb-macro.wrap, when: false, args: {"command":"cursorWordPartRightSelect"},
* ctrl+shift+alt+right, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectRight"},
* ctrl+shift+alt+up, cursorColumnSelectUp, when: textInputFocus,
* ctrl+shift+alt+up, kb-macro.wrap, when: false, args: {"command":"editor.action.copyLinesUpAction"},
* ctrl+shift+alt+up, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectUp"},
* ctrl+shift+b, kb-macro.wrap, when: kb-macro.active && taskCommandsRegistered, args: {"command":"workbench.action.tasks.build"},
* ctrl+shift+b, workbench.action.tasks.build, when: taskCommandsRegistered,
* ctrl+shift+backspace, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"search.searchEditor.action.deleteFileResults"},
* ctrl+shift+backspace, search.searchEditor.action.deleteFileResults, when: inSearchEditor,
* ctrl+shift+c, kb-macro.wrap, when: browserHasUrl && chatIsEnabled && config.chat.sendElementsToChat.enabled && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.addElementToChat"},
* ctrl+shift+c, kb-macro.wrap, when: kb-macro.active && !terminalFocus, args: {"command":"workbench.action.terminal.openNativeConsole"},
* ctrl+shift+c, kb-macro.wrap, when: kb-macro.active && terminalTextSelectedInFocused || kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalTextSelected || kb-macro.active && terminalFocus && terminalProcessSupported && terminalTextSelected || kb-macro.active && terminalFocus && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalHasBeenCreated && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalProcessSupported && terminalTextSelected && terminalTextSelectedInFocused, args: {"command":"workbench.action.terminal.copySelection"},
* ctrl+shift+c, workbench.action.browser.addElementToChat, when: browserHasUrl && chatIsEnabled && config.chat.sendElementsToChat.enabled && !browserHasError && activeEditor == 'workbench.editor.browser',
* ctrl+shift+c, workbench.action.terminal.copySelection, when: terminalTextSelectedInFocused || terminalFocus && terminalHasBeenCreated && terminalTextSelected || terminalFocus && terminalProcessSupported && terminalTextSelected || terminalFocus && terminalTextSelected && terminalTextSelectedInFocused || terminalHasBeenCreated && terminalTextSelected && terminalTextSelectedInFocused || terminalProcessSupported && terminalTextSelected && terminalTextSelectedInFocused,
* ctrl+shift+c, workbench.action.terminal.openNativeConsole, when: !terminalFocus,
* ctrl+shift+d, kb-macro.wrap, when: kb-macro.active && viewContainer.workbench.view.debug.enabled, args: {"command":"workbench.view.debug"},
* ctrl+shift+d, workbench.view.debug, when: viewContainer.workbench.view.debug.enabled,
* ctrl+shift+down, cursorDownSelect, when: textInputFocus,
* ctrl+shift+down, kb-macro.wrap, when: false, args: {"command":"editor.action.insertCursorBelow"},
* ctrl+shift+down, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollDown"},
* ctrl+shift+down, kb-macro.wrap, when: inChat && inChatInput && kb-macro.active && quickChatHasFocus, args: {"command":"workbench.chat.action.focusLastFocused"},
* ctrl+shift+down, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.interactive' || kb-macro.active && activeEditor == 'workbench.editor.notebook' || kb-macro.active && activeEditor == 'workbench.editor.repl', args: {"command":"notebook.cell.focusInOutput"},
* ctrl+shift+down, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.selectToNextCommand"},
* ctrl+shift+down, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorDownSelect"},
* ctrl+shift+down, notebook.cell.focusInOutput, when: activeEditor == 'workbench.editor.interactive' || activeEditor == 'workbench.editor.notebook' || activeEditor == 'workbench.editor.repl',
* ctrl+shift+down, workbench.action.terminal.selectToNextCommand, when: terminalFocus && terminalHasBeenCreated || terminalFocus && terminalProcessSupported,
* ctrl+shift+down, workbench.chat.action.focusLastFocused, when: inChat && inChatInput && quickChatHasFocus,
* ctrl+shift+e, kb-macro.wrap, when: false, args: {"command":"cursorLineEndSelect"},
* ctrl+shift+e, kb-macro.wrap, when: inFilesPicker && inQuickOpen && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigatePreviousInFilePicker"},
* ctrl+shift+e, kb-macro.wrap, when: kb-macro.active && viewContainer.workbench.view.explorer.enabled, args: {"command":"workbench.view.explorer"},
* ctrl+shift+e, workbench.action.quickOpenNavigatePreviousInFilePicker, when: inFilesPicker && inQuickOpen,
* ctrl+shift+e, workbench.view.explorer, when: viewContainer.workbench.view.explorer.enabled,
* ctrl+shift+end, cursorBottomSelect, when: textInputFocus,
* ctrl+shift+end, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorBottomSelect"},
* ctrl+shift+enter, editor.action.insertLineBefore, when: editorTextFocus && !editorReadonly,
* ctrl+shift+enter, kb-macro.wrap, when: chatInputHasText && inChatInput && kb-macro.active, args: {"command":"workbench.action.chat.sendToNewChat"},
* ctrl+shift+enter, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.insertLineBefore"},
* ctrl+shift+enter, kb-macro.wrap, when: fileMatchFocus && isEditableItem && kb-macro.active && replaceActive && searchViewletVisible, args: {"command":"search.action.replaceAllInFile"},
* ctrl+shift+enter, kb-macro.wrap, when: folderMatchFocus && isEditableItem && kb-macro.active && replaceActive && searchViewletVisible, args: {"command":"search.action.replaceAllInFolder"},
* ctrl+shift+enter, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.toggleSelection"},
* ctrl+shift+enter, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && !inputFocus, args: {"command":"notebook.cell.insertCodeCellAbove"},
* ctrl+shift+enter, list.toggleSelection, when: listFocus && !inputFocus && !treestickyScrollFocused,
* ctrl+shift+enter, notebook.cell.insertCodeCellAbove, when: notebookCellListFocused && !inputFocus,
* ctrl+shift+enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* ctrl+shift+enter, search.action.replaceAllInFile, when: fileMatchFocus && isEditableItem && replaceActive && searchViewletVisible,
* ctrl+shift+enter, search.action.replaceAllInFolder, when: folderMatchFocus && isEditableItem && replaceActive && searchViewletVisible,
* ctrl+shift+enter, workbench.action.chat.sendToNewChat, when: chatInputHasText && inChatInput,
* ctrl+shift+f, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalProcessSupported && terminalTextSelected, args: {"command":"workbench.action.terminal.searchWorkspace"},
* ctrl+shift+f, kb-macro.wrap, when: kb-macro.active && workbench.view.search.active && neverMatch =~ /doesNotMatch/, args: {"command":"workbench.view.search"},
* ctrl+shift+f, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.findInFiles"},
* ctrl+shift+f, workbench.action.findInFiles,
* ctrl+shift+f, workbench.action.terminal.searchWorkspace, when: terminalFocus && terminalProcessSupported && terminalTextSelected,
* ctrl+shift+f, workbench.view.search, when: workbench.view.search.active && neverMatch =~ /doesNotMatch/,
* ctrl+shift+f2, editor.action.linkedEditing, when: editorHasRenameProvider && editorTextFocus && !editorReadonly,
* ctrl+shift+f2, kb-macro.wrap, when: editorHasRenameProvider && editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.linkedEditing"},
* ctrl+shift+f3, editor.action.previousSelectionMatchFindAction, when: editorFocus,
* ctrl+shift+f3, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.previousSelectionMatchFindAction"},
* ctrl+shift+f5, kb-macro.wrap, when: inDebugMode && kb-macro.active, args: {"command":"workbench.action.debug.restart"},
* ctrl+shift+f5, workbench.action.debug.restart, when: inDebugMode,
* ctrl+shift+f9, kb-macro.wrap, when: chatIsEnabled && inChat && kb-macro.active, args: {"command":"workbench.action.chat.previousFileTree"},
* ctrl+shift+f9, workbench.action.chat.previousFileTree, when: chatIsEnabled && inChat,
* ctrl+shift+f10, kb-macro.wrap, when: false, args: {"command":"editor.action.peekDefinition"},
* ctrl+shift+f12, editor.action.peekImplementation, when: editorHasImplementationProvider && editorTextFocus && !inReferenceSearchEditor && !isInEmbeddedEditor,
* ctrl+shift+f12, kb-macro.wrap, when: editorHasImplementationProvider && editorTextFocus && kb-macro.active && !inReferenceSearchEditor && !isInEmbeddedEditor, args: {"command":"editor.action.peekImplementation"},
* ctrl+shift+g, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.openDetectedLink"},
* ctrl+shift+g, kb-macro.wrap, when: kb-macro.active && workbench.scm.active, args: {"command":"workbench.view.scm"},
* ctrl+shift+g, workbench.action.terminal.openDetectedLink, when: accessibleViewIsShown && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal',
* ctrl+shift+g, workbench.view.scm, when: workbench.scm.active,
* ctrl+shift+h, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.replaceInFiles"},
* ctrl+shift+h, workbench.action.replaceInFiles,
* ctrl+shift+home, cursorTopSelect, when: textInputFocus,
* ctrl+shift+home, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorTopSelect"},
* ctrl+shift+i, kb-macro.wrap, when: config.chat.agent.enabled && kb-macro.active && !chatSetupDisabled && !chatSetupHidden, args: {"command":"workbench.action.chat.openagent"},
* ctrl+shift+i, kb-macro.wrap, when: false, args: {"command":"editor.action.formatDocument"},
* ctrl+shift+i, kb-macro.wrap, when: false, args: {"command":"editor.action.formatDocument.none"},
* ctrl+shift+i, kb-macro.wrap, when: false, args: {"command":"notebook.format"},
* ctrl+shift+i, kb-macro.wrap, when: false, args: {"command":"notebook.formatCell"},
* ctrl+shift+i, kb-macro.wrap, when: false, args: {"command":"workbench.action.toggleDevTools"},
* ctrl+shift+i, workbench.action.chat.openagent, when: config.chat.agent.enabled && !chatSetupDisabled && !chatSetupHidden,
* ctrl+shift+i, workbench.action.toggleDevTools, when: isDevelopment,
* ctrl+shift+j, kb-macro.wrap, when: inSearchEditor && kb-macro.active || kb-macro.active && searchViewletFocus, args: {"command":"workbench.action.search.toggleQueryDetails"},
* ctrl+shift+j, workbench.action.search.toggleQueryDetails, when: inSearchEditor || searchViewletFocus,
* ctrl+shift+k, editor.action.deleteLines, when: textInputFocus && !editorReadonly,
* ctrl+shift+k, kb-macro.wrap, when: kb-macro.active && textInputFocus && !editorReadonly, args: {"command":"editor.action.deleteLines"},
* ctrl+shift+l, addCursorsAtSearchResults, when: fileMatchOrMatchFocus && searchViewletVisible,
* ctrl+shift+l, editor.action.selectHighlights, when: editorFocus,
* ctrl+shift+l, kb-macro.wrap, when: config.notebook.multiCursor.enabled && kb-macro.active && notebookFindWidgetFocused || config.notebook.multiCursor.enabled && kb-macro.active && notebookCellEditorFocused && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.selectAllFindMatches"},
* ctrl+shift+l, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.selectHighlights"},
* ctrl+shift+l, kb-macro.wrap, when: fileMatchOrMatchFocus && kb-macro.active && searchViewletVisible, args: {"command":"addCursorsAtSearchResults"},
* ctrl+shift+l, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"selectAllSearchEditorMatches"},
* ctrl+shift+l, notebook.selectAllFindMatches, when: config.notebook.multiCursor.enabled && notebookFindWidgetFocused || config.notebook.multiCursor.enabled && notebookCellEditorFocused && activeEditor == 'workbench.editor.notebook',
* ctrl+shift+l, selectAllSearchEditorMatches, when: inSearchEditor,
* ctrl+shift+left, cursorWordAccessibilityLeftSelect, when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* ctrl+shift+left, cursorWordLeftSelect, when: textInputFocus && !accessibilityModeEnabled,
* ctrl+shift+left, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && textInputFocus && focusedView == 'workbench.panel.output', args: {"command":"cursorWordAccessibilityLeftSelect"},
* ctrl+shift+left, kb-macro.wrap, when: false, args: {"command":"cursorWordLeftSelect"},
* ctrl+shift+left, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.resizePaneLeft"},
* ctrl+shift+left, kb-macro.wrap, when: kb-macro.active && textInputFocus && !accessibilityModeEnabled, args: {"command":"cursorWordLeftSelect"},
* ctrl+shift+m, kb-macro.wrap, when: false, args: {"command":"editor.action.toggleTabFocusMode"},
* ctrl+shift+m, kb-macro.wrap, when: kb-macro.active && workbench.panel.markers.view.active, args: {"command":"workbench.actions.view.problems"},
* ctrl+shift+m, workbench.actions.view.problems, when: workbench.panel.markers.view.active,
* ctrl+shift+n, chatEditor.action.reject, when: chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
* ctrl+shift+n, kb-macro.wrap, when: chatEdits.hasEditorModifications && editorFocus && kb-macro.active && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && kb-macro.active && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified, args: {"command":"chatEditor.action.reject"},
* ctrl+shift+n, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.newWindow"},
* ctrl+shift+n, workbench.action.newWindow,
* ctrl+shift+o, editor.action.accessibleViewGoToSymbol, when: accessibilityHelpIsShown && accessibleViewGoToSymbolSupported || accessibleViewGoToSymbolSupported && accessibleViewIsShown,
* ctrl+shift+o, kb-macro.wrap, when: accessibilityHelpIsShown && accessibleViewGoToSymbolSupported && kb-macro.active || accessibleViewGoToSymbolSupported && accessibleViewIsShown && kb-macro.active, args: {"command":"editor.action.accessibleViewGoToSymbol"},
* ctrl+shift+o, kb-macro.wrap, when: kb-macro.active && !accessibilityHelpIsShown && !accessibleViewIsShown, args: {"command":"workbench.action.gotoSymbol"},
* ctrl+shift+o, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated, args: {"command":"workbench.action.terminal.openDetectedLink"},
* ctrl+shift+o, workbench.action.gotoSymbol, when: !accessibilityHelpIsShown && !accessibleViewIsShown,
* ctrl+shift+o, workbench.action.terminal.openDetectedLink, when: terminalFocus && terminalHasBeenCreated,
* ctrl+shift+oem_102, kb-macro.wrap, when: false, args: {"command":"breadcrumbs.focusAndSelect"},
* ctrl+shift+oem_102, kb-macro.wrap, when: false, args: {"command":"breadcrumbs.toggleToOn"},
* ctrl+shift+oem_102, kb-macro.wrap, when: false, args: {"command":"editor.action.accessibleViewGoToSymbol"},
* ctrl+shift+oem_102, kb-macro.wrap, when: false, args: {"command":"editor.action.inPlaceReplace.down"},
* ctrl+shift+p, kb-macro.wrap, when: inFilesPicker && inQuickOpen && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigatePreviousInFilePicker"},
* ctrl+shift+p, workbench.action.quickOpenNavigatePreviousInFilePicker, when: inFilesPicker && inQuickOpen,
* ctrl+shift+p, workbench.action.showCommands,
* ctrl+shift+p, workbench.action.showCommands, when: kb-macro.active,
* ctrl+shift+pagedown, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveEditorRightInGroup"},
* ctrl+shift+pagedown, workbench.action.moveEditorRightInGroup,
* ctrl+shift+pageup, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveEditorLeftInGroup"},
* ctrl+shift+pageup, workbench.action.moveEditorLeftInGroup,
* ctrl+shift+q, kb-macro.wrap, when: inQuickOpen && inViewsPicker && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigatePreviousInViewPicker"},
* ctrl+shift+q, workbench.action.quickOpenNavigatePreviousInViewPicker, when: inQuickOpen && inViewsPicker,
* ctrl+shift+r, editor.action.refactor, when: editorHasCodeActionsProvider && textInputFocus && !editorReadonly,
* ctrl+shift+r, kb-macro.wrap, when: browserFocused && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.hardReload"},
* ctrl+shift+r, kb-macro.wrap, when: editorHasCodeActionsProvider && kb-macro.active && textInputFocus && !editorReadonly, args: {"command":"editor.action.refactor"},
* ctrl+shift+r, kb-macro.wrap, when: inQuickOpen && inRecentFilesPicker && kb-macro.active, args: {"command":"workbench.action.quickOpenNavigatePreviousInRecentFilesPicker"},
* ctrl+shift+r, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"rerunSearchEditorSearch"},
* ctrl+shift+r, kb-macro.wrap, when: kb-macro.active && taskTerminalActive && terminalFocus, args: {"command":"workbench.action.tasks.rerunForActiveTerminal"},
* ctrl+shift+r, rerunSearchEditorSearch, when: inSearchEditor,
* ctrl+shift+r, workbench.action.browser.hardReload, when: browserFocused && activeEditor == 'workbench.editor.browser',
* ctrl+shift+r, workbench.action.quickOpenNavigatePreviousInRecentFilesPicker, when: inQuickOpen && inRecentFilesPicker,
* ctrl+shift+r, workbench.action.tasks.rerunForActiveTerminal, when: taskTerminalActive && terminalFocus,
* ctrl+shift+right, cursorWordAccessibilityRightSelect, when: accessibilityModeEnabled && isWindows && textInputFocus && focusedView == 'workbench.panel.output',
* ctrl+shift+right, cursorWordEndRightSelect, when: textInputFocus && !accessibilityModeEnabled,
* ctrl+shift+right, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && textInputFocus && focusedView == 'workbench.panel.output', args: {"command":"cursorWordAccessibilityRightSelect"},
* ctrl+shift+right, kb-macro.wrap, when: false, args: {"command":"cursorWordEndRightSelect"},
* ctrl+shift+right, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.resizePaneRight"},
* ctrl+shift+right, kb-macro.wrap, when: kb-macro.active && textInputFocus && !accessibilityModeEnabled, args: {"command":"cursorWordEndRightSelect"},
* ctrl+shift+s, kb-macro.wrap, when: kb-macro.active && remoteFileDialogVisible, args: {"command":"workbench.action.files.saveLocalFile"},
* ctrl+shift+s, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.saveAs"},
* ctrl+shift+s, workbench.action.files.saveAs,
* ctrl+shift+s, workbench.action.files.saveLocalFile, when: remoteFileDialogVisible,
* ctrl+shift+space, editor.action.triggerParameterHints, when: editorHasSignatureHelpProvider && editorTextFocus,
* ctrl+shift+space, kb-macro.wrap, when: editorHasSignatureHelpProvider && editorTextFocus && kb-macro.active, args: {"command":"editor.action.triggerParameterHints"},
* ctrl+shift+t, kb-macro.wrap, when: inChatInput && kb-macro.active && chatAgentKind == 'agent' || inChatTodoList && kb-macro.active && chatAgentKind == 'agent', args: {"command":"workbench.action.chat.focusTodosView"},
* ctrl+shift+t, kb-macro.wrap, when: isMergeEditor && kb-macro.active, args: {"command":"mergeEditor.toggleBetweenInputs"},
* ctrl+shift+t, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.reopenClosedEditor"},
* ctrl+shift+t, mergeEditor.toggleBetweenInputs, when: isMergeEditor,
* ctrl+shift+t, workbench.action.chat.focusTodosView, when: inChatInput && chatAgentKind == 'agent' || inChatTodoList && chatAgentKind == 'agent',
* ctrl+shift+t, workbench.action.reopenClosedEditor,
* ctrl+shift+tab, workbench.action.quickOpenLeastRecentlyUsedEditorInGroup, when: !activeEditorGroupEmpty,
* ctrl+shift+tab, workbench.action.quickOpenLeastRecentlyUsedEditorInGroup, when: kb-macro.active && !activeEditorGroupEmpty,
* ctrl+shift+tab, workbench.action.quickOpenNavigatePreviousInEditorPicker, when: inEditorsPicker && inQuickOpen && kb-macro.active,
* ctrl+shift+tab, workbench.action.quickOpenNavigatePreviousInEditorPicker, when: inEditorsPicker && inQuickOpen,
* ctrl+shift+u, kb-macro.wrap, when: kb-macro.active && workbench.panel.output.active, args: {"command":"workbench.action.output.toggleOutput"},
* ctrl+shift+u, workbench.action.output.toggleOutput, when: workbench.panel.output.active,
* ctrl+shift+up, cursorUpSelect, when: textInputFocus,
* ctrl+shift+up, kb-macro.wrap, when: chatCursorAtTop && inChatInput && kb-macro.active && !quickChatHasFocus, args: {"command":"workbench.chat.action.focusLastFocused"},
* ctrl+shift+up, kb-macro.wrap, when: false, args: {"command":"editor.action.insertCursorAbove"},
* ctrl+shift+up, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollUp"},
* ctrl+shift+up, kb-macro.wrap, when: inChatInput && kb-macro.active && !quickChatHasFocus, args: {"command":"workbench.chat.action.focusLastFocused"},
* ctrl+shift+up, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && notebookOutputFocused, args: {"command":"notebook.cell.focusOutOutput"},
* ctrl+shift+up, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.selectToPreviousCommand"},
* ctrl+shift+up, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorUpSelect"},
* ctrl+shift+up, notebook.cell.focusOutOutput, when: notebookEditorFocused && notebookOutputFocused,
* ctrl+shift+up, workbench.action.terminal.selectToPreviousCommand, when: terminalFocus && terminalHasBeenCreated || terminalFocus && terminalProcessSupported,
* ctrl+shift+up, workbench.chat.action.focusLastFocused, when: chatCursorAtTop && inChatInput && !quickChatHasFocus,
* ctrl+shift+up, workbench.chat.action.focusLastFocused, when: inChatInput && isLinux && !quickChatHasFocus || inChatInput && isWindows && !quickChatHasFocus,
* ctrl+shift+v, kb-macro.wrap, when: kb-macro.active && !notebookEditorFocused && editorLangId =~ /^(markdown|prompt|instructions|chatagent|skill)$/, args: {"command":"markdown.showPreview"},
* ctrl+shift+v, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.pasteAbove"},
* ctrl+shift+v, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.paste"},
* ctrl+shift+v, markdown.showPreview, when: !notebookEditorFocused && editorLangId =~ /^(markdown|prompt|instructions|chatagent|skill)$/,
* ctrl+shift+v, notebook.cell.pasteAbove, when: notebookEditorFocused && !inputFocus,
* ctrl+shift+v, workbench.action.terminal.paste, when: terminalFocus && terminalHasBeenCreated || terminalFocus && terminalProcessSupported,
* ctrl+shift+w, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeWindow"},
* ctrl+shift+w, workbench.action.closeWindow,
* ctrl+shift+win+left, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.smartSelect.shrink"},
* ctrl+shift+win+right, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.smartSelect.expand"},
* ctrl+shift+x, kb-macro.wrap, when: kb-macro.active && viewContainer.workbench.view.extensions.enabled, args: {"command":"workbench.view.extensions"},
* ctrl+shift+x, workbench.view.extensions, when: viewContainer.workbench.view.extensions.enabled,
* ctrl+shift+y, chatEditor.action.accept, when: chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified,
* ctrl+shift+y, kb-macro.wrap, when: chatEdits.hasEditorModifications && editorFocus && kb-macro.active && !chatEdits.isCurrentlyBeingModified || chatEdits.hasEditorModifications && kb-macro.active && notebookEditorFocused && !chatEdits.isCurrentlyBeingModified, args: {"command":"chatEditor.action.accept"},
* ctrl+shift+y, kb-macro.wrap, when: kb-macro.active && workbench.panel.repl.view.active, args: {"command":"workbench.debug.action.toggleRepl"},
* ctrl+shift+y, workbench.debug.action.toggleRepl, when: workbench.panel.repl.view.active,
* ctrl+shift+z, kb-macro.wrap, when: kb-macro.active, args: {"command":"redo"},
* ctrl+shift+z, redo,
* ctrl+space, editor.action.triggerSuggest, when: editorHasCompletionItemProvider && textInputFocus && !editorReadonly && !suggestWidgetVisible,
* ctrl+space, focusSuggestion, when: suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* ctrl+space, kb-macro.wrap, when: config.terminal.integrated.enableWin32InputMode && kb-macro.active && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[24~a"}},
* ctrl+space, kb-macro.wrap, when: config.terminal.integrated.suggest.enabled && kb-macro.active && terminalFocus && terminalProcessSupported && !terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.triggerSuggest"},
* ctrl+space, kb-macro.wrap, when: editorHasCompletionItemProvider && kb-macro.active && textInputFocus && !editorReadonly && !suggestWidgetVisible, args: {"command":"editor.action.triggerSuggest","record":"side-effect"},
* ctrl+space, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.toggleHover"},
* ctrl+space, kb-macro.wrap, when: kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.suggestToggleDetails"},
* ctrl+space, kb-macro.wrap, when: kb-macro.active && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus, args: {"command":"toggleSuggestionDetails","record":"side-effect"},
* ctrl+space, kb-macro.wrap, when: kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"focusSuggestion","record":"side-effect"},
* ctrl+space, quickInput.toggleHover, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+space, toggleSuggestionDetails, when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* ctrl+space, workbench.action.terminal.sendSequence, when: config.terminal.integrated.enableWin32InputMode && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"text":"\u001b[24~a"},
* ctrl+space, workbench.action.terminal.suggestToggleDetails, when: simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* ctrl+space, workbench.action.terminal.triggerSuggest, when: config.terminal.integrated.suggest.enabled && terminalFocus && terminalProcessSupported && !terminalSuggestWidgetVisible,
* ctrl+t, kb-macro.wrap, when: false, args: {"command":"editor.action.transposeLetters"},
* ctrl+t, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.newTab"},
* ctrl+t, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.showAllSymbols"},
* ctrl+t, workbench.action.browser.newTab, when: activeEditor == 'workbench.editor.browser',
* ctrl+t, workbench.action.showAllSymbols,
* ctrl+tab, workbench.action.quickOpenNavigateNextInEditorPicker, when: inEditorsPicker && inQuickOpen && kb-macro.active,
* ctrl+tab, workbench.action.quickOpenNavigateNextInEditorPicker, when: inEditorsPicker && inQuickOpen,
* ctrl+tab, workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup, when: !activeEditorGroupEmpty,
* ctrl+tab, workbench.action.quickOpenPreviousRecentlyUsedEditorInGroup, when: kb-macro.active && !activeEditorGroupEmpty,
* ctrl+u, cursorUndo, when: textInputFocus,
* ctrl+u, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorUndo"},
* ctrl+up, chat.action.focus, when: chatCursorAtTop && inChatInput && !quickChatHasFocus,
* ctrl+up, chat.action.focus, when: inChatInput && isLinux && !quickChatHasFocus || inChatInput && isWindows && !quickChatHasFocus,
* ctrl+up, editor.action.goToTopHover, when: editorHoverFocused,
* ctrl+up, inlineChat.focus, when: editorTextFocus && inlineChatVisible && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'below',
* ctrl+up, interactive.history.focus, when: isCompositeNotebook && !notebookEditorFocused && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none',
* ctrl+up, interactive.history.focus, when: isCompositeNotebook && isLinux && !notebookEditorFocused || isCompositeNotebook && isWindows && !notebookEditorFocused,
* ctrl+up, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && searchViewletVisible || firstMatchFocus && kb-macro.active && searchViewletVisible, args: {"command":"search.action.focusSearchFromResults"},
* ctrl+up, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.focusAccessibleBuffer"},
* ctrl+up, kb-macro.wrap, when: chatCursorAtTop && inChatInput && kb-macro.active && !quickChatHasFocus, args: {"command":"chat.action.focus"},
* ctrl+up, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.goToTopHover"},
* ctrl+up, kb-macro.wrap, when: editorTextFocus && inlineChatVisible && kb-macro.active && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'below', args: {"command":"inlineChat.focus"},
* ctrl+up, kb-macro.wrap, when: inChat && kb-macro.active && quickChatHasFocus && !inChatInput, args: {"command":"workbench.action.chat.focusInput"},
* ctrl+up, kb-macro.wrap, when: inChatInput && kb-macro.active && !quickChatHasFocus, args: {"command":"chat.action.focus"},
* ctrl+up, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.previous"},
* ctrl+up, kb-macro.wrap, when: inSearchEditor && inputBoxFocus && kb-macro.active || inputBoxFocus && kb-macro.active && searchViewletVisible && !searchInputBoxFocus, args: {"command":"search.focus.previousInputBox"},
* ctrl+up, kb-macro.wrap, when: inputFocus && kb-macro.active && navigableContainerFocused || kb-macro.active && navigableContainerFocused && treestickyScrollFocused || kb-macro.active && navigableContainerFocused && !listFocus || kb-macro.active && navigableContainerFocused && listScrollAtBoundary == 'both' || kb-macro.active && navigableContainerFocused && listScrollAtBoundary == 'top', args: {"command":"widgetNavigation.focusPrevious"},
* ctrl+up, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !notebookEditorFocused && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none', args: {"command":"interactive.history.focus"},
* ctrl+up, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !notebookEditorFocused, args: {"command":"interactive.history.focus"},
* ctrl+up, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused && listScrollAtBoundary != 'both' && listScrollAtBoundary != 'top', args: {"command":"list.scrollUp"},
* ctrl+up, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectPrevSuggestion","record":"side-effect"},
* ctrl+up, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || kb-macro.active && terminalFocus && terminalProcessSupported && !accessibilityModeEnabled, args: {"command":"workbench.action.terminal.scrollToPreviousCommand"},
* ctrl+up, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"scrollLineUp"},
* ctrl+up, list.scrollUp, when: listFocus && !inputFocus && !treestickyScrollFocused && listScrollAtBoundary != 'both' && listScrollAtBoundary != 'top',
* ctrl+up, quickInput.previous, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* ctrl+up, scrollLineUp, when: textInputFocus,
* ctrl+up, search.action.focusSearchFromResults, when: accessibilityModeEnabled && searchViewletVisible || firstMatchFocus && searchViewletVisible,
* ctrl+up, search.focus.previousInputBox, when: inSearchEditor && inputBoxFocus || inputBoxFocus && searchViewletVisible && !searchInputBoxFocus,
* ctrl+up, selectPrevCodeAction, when: codeActionMenuVisible && kb-macro.active,
* ctrl+up, selectPrevCodeAction, when: codeActionMenuVisible,
* ctrl+up, selectPrevSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* ctrl+up, widgetNavigation.focusPrevious, when: inputFocus && navigableContainerFocused || navigableContainerFocused && treestickyScrollFocused || navigableContainerFocused && !listFocus || navigableContainerFocused && listScrollAtBoundary == 'both' || navigableContainerFocused && listScrollAtBoundary == 'top',
* ctrl+up, workbench.action.chat.focusInput, when: inChat && quickChatHasFocus && !inChatInput,
* ctrl+up, workbench.action.terminal.focusAccessibleBuffer, when: accessibilityModeEnabled && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && terminalFocus && terminalProcessSupported,
* ctrl+up, workbench.action.terminal.scrollToPreviousCommand, when: terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || terminalFocus && terminalProcessSupported && !accessibilityModeEnabled,
* ctrl+v, editor.action.clipboardPasteAction,
* ctrl+v, filesExplorer.paste, when: filesExplorerFocus && foldersViewVisible && !explorerResourceReadonly && !inputFocus,
* ctrl+v, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceReadonly && !inputFocus, args: {"command":"filesExplorer.paste"},
* ctrl+v, kb-macro.wrap, when: kb-macro.active && terminalFocus && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0016"}},
* ctrl+v, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.paste"},
* ctrl+v, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.clipboardPasteAction","await":"document selection"},
* ctrl+v, workbench.action.terminal.paste, when: terminalFocus && terminalHasBeenCreated || terminalFocus && terminalProcessSupported,
* ctrl+v, workbench.action.terminal.sendSequence, when: terminalFocus && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"text":"\u0016"},
* ctrl+w, kb-macro.wrap, when: activeEditorGroupEmpty && kb-macro.active && multipleEditorGroups, args: {"command":"workbench.action.closeGroup"},
* ctrl+w, kb-macro.wrap, when: auxiliaryBarMaximized && kb-macro.active, args: {"command":"workbench.action.restoreAuxiliaryBar"},
* ctrl+w, kb-macro.wrap, when: false, args: {"command":"workbench.action.switchWindow"},
* ctrl+w, kb-macro.wrap, when: kb-macro.active && terminalEditorFocus && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalEditorFocus && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.killEditor"},
* ctrl+w, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.closeActiveEditor"},
* ctrl+w, workbench.action.closeActiveEditor,
* ctrl+w, workbench.action.closeGroup, when: activeEditorGroupEmpty && multipleEditorGroups,
* ctrl+w, workbench.action.restoreAuxiliaryBar, when: auxiliaryBarMaximized,
* ctrl+w, workbench.action.terminal.killEditor, when: terminalEditorFocus && terminalFocus && terminalHasBeenCreated || terminalEditorFocus && terminalFocus && terminalProcessSupported,
* ctrl+win+down, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.nextSeparator"},
* ctrl+win+down, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.resizePaneDown"},
* ctrl+win+end, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.last"},
* ctrl+win+enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* ctrl+win+escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* ctrl+win+home, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.first"},
* ctrl+win+left, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.resizePaneLeft"},
* ctrl+win+pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* ctrl+win+pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* ctrl+win+right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* ctrl+win+right, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.resizePaneRight"},
* ctrl+win+up, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.previousSeparator"},
* ctrl+win+up, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.resizePaneUp"},
* ctrl+x, editor.action.clipboardCutAction,
* ctrl+x, filesExplorer.cut, when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsRoot && !explorerResourceReadonly && !inputFocus,
* ctrl+x, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceIsRoot && !explorerResourceReadonly && !inputFocus, args: {"command":"filesExplorer.cut"},
* ctrl+x, kb-macro.wrap, when: kb-macro.active && !kb-macro.headOfLine, args: {"command":"editor.action.clipboardCutAction","await":"document selection clipboard"},
* ctrl+x, kb-macro.wrap, when: kb-macro.active && kb-macro.headOfLine, args: {"command":"editor.action.clipboardCutAction","await":"document clipboard"},
* ctrl+y, chatEditor.action.acceptHunk, when: chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified || chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && notebookCellListFocused && !chatEdits.isCurrentlyBeingModified,
* ctrl+y, kb-macro.wrap, when: chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && editorFocus && kb-macro.active && !chatEdits.isCurrentlyBeingModified || chatEdits.cursorInChangeRange && chatEdits.hasEditorModifications && kb-macro.active && notebookCellListFocused && !chatEdits.isCurrentlyBeingModified, args: {"command":"chatEditor.action.acceptHunk"},
* ctrl+y, kb-macro.wrap, when: kb-macro.active, args: {"command":"redo"},
* ctrl+y, redo,
* ctrl+z, kb-macro.wrap, when: kb-macro.active, args: {"command":"undo"},
* ctrl+z, undo,
* delete, agentSession.archive, when: agentSessionsViewerFocused && !agentSessionIsArchived,
* delete, debug.removeBreakpoint, when: breakpointsFocused && !breakpointInputFocused,
* delete, debug.removeWatchExpression, when: watchExpressionsFocused && !expressionSelected,
* delete, deleteFile, when: filesExplorerFocus && foldersViewVisible && !explorerResourceMoveableToTrash && !inputFocus,
* delete, deleteRight, when: textInputFocus,
* delete, kb-macro.wrap, when: agentSessionsViewerFocused && kb-macro.active && !agentSessionIsArchived, args: {"command":"agentSession.archive"},
* delete, kb-macro.wrap, when: breakpointsFocused && kb-macro.active && !breakpointInputFocused, args: {"command":"debug.removeBreakpoint"},
* delete, kb-macro.wrap, when: config.notebook.multiCursor.enabled && isNotebookMultiSelect && kb-macro.active && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '1' || config.notebook.multiCursor.enabled && isNotebookMultiSelect && kb-macro.active && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '2', args: {"command":"noteMultiCursor.deleteRight"},
* delete, kb-macro.wrap, when: explorerResourceMoveableToTrash && filesExplorerFocus && foldersViewVisible && kb-macro.active && !inputFocus, args: {"command":"moveFileToTrash"},
* delete, kb-macro.wrap, when: fileMatchOrMatchFocus && kb-macro.active && searchViewletVisible, args: {"command":"search.action.remove"},
* delete, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceMoveableToTrash && !inputFocus, args: {"command":"deleteFile"},
* delete, kb-macro.wrap, when: inChat && kb-macro.active && !inChatQuestionCarousel && !textInputFocus, args: {"command":"workbench.action.chat.restoreCheckpoint"},
* delete, kb-macro.wrap, when: inChat && kb-macro.active && !inChatQuestionCarousel && !textInputFocus, args: {"command":"workbench.action.chat.undoEdits"},
* delete, kb-macro.wrap, when: inKeybindings && kb-macro.active && keybindingFocus && !inputFocus, args: {"command":"keybindings.editor.removeKeybinding"},
* delete, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus && !notebookOutputInputFocused, args: {"command":"notebook.cell.delete"},
* delete, kb-macro.wrap, when: kb-macro.active && notificationFocus, args: {"command":"notification.clear"},
* delete, kb-macro.wrap, when: kb-macro.active && terminalHasBeenCreated && terminalTabsFocus || kb-macro.active && terminalIsOpen && terminalTabsFocus || kb-macro.active && terminalProcessSupported && terminalTabsFocus, args: {"command":"workbench.action.terminal.killActiveTab"},
* delete, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"deleteRight"},
* delete, kb-macro.wrap, when: kb-macro.active && tunnelCloseable && tunnelViewFocus, args: {"command":"remote.tunnel.closeInline"},
* delete, kb-macro.wrap, when: kb-macro.active && watchExpressionsFocused && !expressionSelected, args: {"command":"debug.removeWatchExpression"},
* delete, keybindings.editor.removeKeybinding, when: inKeybindings && keybindingFocus && !inputFocus,
* delete, moveFileToTrash, when: explorerResourceMoveableToTrash && filesExplorerFocus && foldersViewVisible && !inputFocus,
* delete, noteMultiCursor.deleteRight, when: config.notebook.multiCursor.enabled && isNotebookMultiSelect && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '1' || config.notebook.multiCursor.enabled && isNotebookMultiSelect && activeEditor == 'workbench.editor.notebook' && notebookMultiSelectCursorState == '2',
* delete, notebook.cell.delete, when: notebookEditorFocused && !inputFocus && !notebookOutputInputFocused,
* delete, notification.clear, when: notificationFocus,
* delete, remote.tunnel.closeInline, when: tunnelCloseable && tunnelViewFocus,
* delete, search.action.remove, when: fileMatchOrMatchFocus && searchViewletVisible,
* delete, workbench.action.chat.restoreCheckpoint, when: inChat && !inChatQuestionCarousel && !textInputFocus,
* delete, workbench.action.chat.undoEdits, when: inChat && !inChatQuestionCarousel && !textInputFocus,
* delete, workbench.action.terminal.killActiveTab, when: terminalHasBeenCreated && terminalTabsFocus || terminalIsOpen && terminalTabsFocus || terminalProcessSupported && terminalTabsFocus,
* down, breadcrumbs.selectFocused, when: breadcrumbsActive && breadcrumbsVisible,
* down, cursorDown, when: textInputFocus,
* down, editor.action.scrollDownHover, when: editorHoverFocused,
* down, editor.action.selectNextStickyScrollLine, when: stickyScrollFocused,
* down, focusNextRenameSuggestion, when: renameInputVisible,
* down, history.showNext, when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* down, iconSelectBox.focusDown, when: iconSelectBoxFocus,
* down, interactive.history.next, when: isCompositeNotebook && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'none' && interactiveInputCursorAtBoundary != 'top',
* down, kb-macro.wrap, when: bannerFocused && kb-macro.active, args: {"command":"workbench.banner.focusNextAction"},
* down, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.selectFocused"},
* down, kb-macro.wrap, when: config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'both' && notebookEditorCursorAtBoundary != 'none' && notebookEditorCursorAtBoundary != 'top' || config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'end' && notebookEditorCursorAtBoundary != 'none' && notebookEditorCursorAtBoundary != 'top', args: {"command":"notebook.focusNextEditor"},
* down, kb-macro.wrap, when: config.notebook.navigation.allowNavigateToSurroundingCells && kb-macro.active && notebookCursorNavigationMode && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && !notebookCellMarkdownEditMode && notebookCellType == 'markup', args: {"command":"notebook.focusNextEditor"},
* down, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.scrollDownHover"},
* down, kb-macro.wrap, when: historyNavigationForwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible, args: {"command":"history.showNext"},
* down, kb-macro.wrap, when: iconSelectBoxFocus && kb-macro.active, args: {"command":"iconSelectBox.focusDown"},
* down, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.next"},
* down, kb-macro.wrap, when: inSettingsSearch && kb-macro.active && !suggestWidgetVisible, args: {"command":"settings.action.focusSettingsFile"},
* down, kb-macro.wrap, when: inSettingsSearch && kb-macro.active && !suggestWidgetVisible, args: {"command":"settings.action.focusSettingsFromSearch"},
* down, kb-macro.wrap, when: interactivePlaygroundFocus && kb-macro.active && !editorTextFocus, args: {"command":"workbench.action.interactivePlayground.arrowDown"},
* down, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'none' && interactiveInputCursorAtBoundary != 'top', args: {"command":"interactive.history.next"},
* down, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusDown"},
* down, kb-macro.wrap, when: kb-macro.active && notebookOutputInputFocused, args: {"command":"notebook.cell.nullAction"},
* down, kb-macro.wrap, when: kb-macro.active && notificationFocus && notificationToastsVisible, args: {"command":"notifications.focusNextToast"},
* down, kb-macro.wrap, when: kb-macro.active && renameInputVisible, args: {"command":"focusNextRenameSuggestion"},
* down, kb-macro.wrap, when: kb-macro.active && scmInputIsInLastPosition && scmRepository && !suggestWidgetVisible, args: {"command":"scm.viewNextCommit"},
* down, kb-macro.wrap, when: kb-macro.active && statusBarFocused, args: {"command":"workbench.statusBar.focusNext"},
* down, kb-macro.wrap, when: kb-macro.active && stickyScrollFocused, args: {"command":"editor.action.selectNextStickyScrollLine"},
* down, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectNextSuggestion","record":"side-effect"},
* down, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.selectNextSuggestion"},
* down, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorDown"},
* down, list.focusDown, when: listFocus && !inputFocus && !treestickyScrollFocused,
* down, notebook.cell.nullAction, when: notebookOutputInputFocused,
* down, notebook.focusNextEditor, when: config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'both' && notebookEditorCursorAtBoundary != 'none' && notebookEditorCursorAtBoundary != 'top' || config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'end' && notebookEditorCursorAtBoundary != 'none' && notebookEditorCursorAtBoundary != 'top',
* down, notebook.focusNextEditor, when: config.notebook.navigation.allowNavigateToSurroundingCells && notebookCursorNavigationMode && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && !notebookCellMarkdownEditMode && notebookCellType == 'markup',
* down, notifications.focusNextToast, when: notificationFocus && notificationToastsVisible,
* down, quickInput.next, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* down, scm.viewNextCommit, when: scmInputIsInLastPosition && scmRepository && !suggestWidgetVisible,
* down, selectNextCodeAction, when: codeActionMenuVisible && kb-macro.active,
* down, selectNextCodeAction, when: codeActionMenuVisible,
* down, selectNextSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* down, settings.action.focusSettingsFile, when: inSettingsSearch && !suggestWidgetVisible,
* down, settings.action.focusSettingsFromSearch, when: inSettingsSearch && !suggestWidgetVisible,
* down, showNextParameterHint, when: editorFocus && kb-macro.active && parameterHintsMultipleSignatures && parameterHintsVisible,
* down, showNextParameterHint, when: editorFocus && parameterHintsMultipleSignatures && parameterHintsVisible,
* down, workbench.action.interactivePlayground.arrowDown, when: interactivePlaygroundFocus && !editorTextFocus,
* down, workbench.action.terminal.selectNextSuggestion, when: terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* down, workbench.banner.focusNextAction, when: bannerFocused,
* down, workbench.statusBar.focusNext, when: statusBarFocused,
* end, cursorEnd, when: textInputFocus, args: {"sticky":false},
* end, editor.action.goToBottomHover, when: editorHoverFocused,
* end, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.goToBottomHover"},
* end, kb-macro.wrap, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerViewletCompressedLastFocus && !inputFocus, args: {"command":"lastCompressedFolder"},
* end, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusLast"},
* end, kb-macro.wrap, when: kb-macro.active && notificationFocus && notificationToastsVisible, args: {"command":"notifications.focusLastToast"},
* end, kb-macro.wrap, when: kb-macro.active && statusBarFocused, args: {"command":"workbench.statusBar.focusLast"},
* end, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorEnd","args":{"sticky":false}},
* end, lastCompressedFolder, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && !explorerViewletCompressedLastFocus && !inputFocus,
* end, list.focusLast, when: listFocus && !inputFocus && !treestickyScrollFocused,
* end, notifications.focusLastToast, when: notificationFocus && notificationToastsVisible,
* end, workbench.statusBar.focusLast, when: statusBarFocused,
* enter, acceptRenameInput, when: editorFocus && renameInputVisible && !isComposing,
* enter, acceptSelectedCodeAction, when: codeActionMenuVisible && kb-macro.active,
* enter, acceptSelectedCodeAction, when: codeActionMenuVisible,
* enter, acceptSelectedSuggestion, when: acceptSuggestionOnEnter && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && suggestionMakesTextEdit && textInputFocus,
* enter, breadcrumbs.selectFocused, when: breadcrumbsActive && breadcrumbsVisible,
* enter, breakpointWidget.action.acceptInput, when: breakpointWidgetVisible && inBreakpointWidget,
* enter, editor.action.extensioneditor.findNext, when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'workbench.editor.extension',
* enter, editor.action.goToFocusedStickyScrollLine, when: stickyScrollFocused,
* enter, editor.action.insertColorWithStandaloneColorPicker, when: standaloneColorPickerFocused,
* enter, editor.action.nextMatchFindAction, when: editorFocus && findInputFocussed,
* enter, editor.action.replaceOne, when: editorFocus && findWidgetVisible && replaceInputFocussed && !isComposing,
* enter, editor.action.webvieweditor.findNext, when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'WebviewEditor',
* enter, explorer.openAndPassFocus, when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsFolder && !inputFocus,
* enter, iconSelectBox.selectFocused, when: iconSelectBoxFocus,
* enter, inlineChat.queueInChat, when: config.inlineChat.askInChat && inlineChatFileBelongsToChat && inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused || config.inlineChat.askInChat && inlineChatFileBelongsToChat && inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && activeEditor == 'workbench.editor.notebook',
* enter, inlineChat.submitInput, when: inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat || inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !inlineChatFileBelongsToChat || inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat && !inlineChatFileBelongsToChat || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat && activeEditor == 'workbench.editor.notebook' || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && !config.inlineChat.askInChat && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook',
* enter, inlineChat2.keep, when: chatEdits.hasEditorModifications && chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.isRequestInProgress && !chatInputHasText || chatEdits.hasEditorModifications && chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.isRequestInProgress && !chatInputHasText && activeEditor == 'workbench.editor.notebook',
* enter, interactive.execute, when: isCompositeNotebook && !config.interactiveWindow.executeWithShiftEnter && activeEditor == 'workbench.editor.interactive',
* enter, kb-macro.wrap, when: acceptSuggestionOnEnter && kb-macro.active && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && suggestionMakesTextEdit && textInputFocus, args: {"command":"acceptSelectedSuggestion","record":"side-effect"},
* enter, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.selectFocused"},
* enter, kb-macro.wrap, when: breakpointWidgetVisible && inBreakpointWidget && kb-macro.active, args: {"command":"breakpointWidget.action.acceptInput"},
* enter, kb-macro.wrap, when: browserFindWidgetFocused && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.findNext"},
* enter, kb-macro.wrap, when: chatEdits.hasEditorModifications && chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active && !chatEdits.isRequestInProgress && !chatInputHasText || chatEdits.hasEditorModifications && chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && !chatEdits.isRequestInProgress && !chatInputHasText && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat2.keep"},
* enter, kb-macro.wrap, when: chatInputHasText && chatSessionOptionsValid && inChatInput && kb-macro.active && !chatSessionRequestInProgress && !withinEditSessionDiff, args: {"command":"workbench.action.chat.submit"},
* enter, kb-macro.wrap, when: chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st' && config.chat.requestQueuing.defaultAction != 'steer', args: {"command":"workbench.action.chat.queueMessage"},
* enter, kb-macro.wrap, when: chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && kb-macro.active && config.chat.requestQueuing.defaultAction == 'steer' && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st', args: {"command":"workbench.action.chat.steerWithMessage"},
* enter, kb-macro.wrap, when: config.inlineChat.askInChat && inlineChatFileBelongsToChat && inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active || config.inlineChat.askInChat && inlineChatFileBelongsToChat && inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat.queueInChat"},
* enter, kb-macro.wrap, when: editorFocus && findInputFocussed && kb-macro.active, args: {"command":"editor.action.nextMatchFindAction"},
* enter, kb-macro.wrap, when: editorFocus && findWidgetVisible && kb-macro.active && replaceInputFocussed && !isComposing, args: {"command":"editor.action.replaceOne"},
* enter, kb-macro.wrap, when: editorFocus && kb-macro.active && renameInputVisible && !isComposing, args: {"command":"acceptRenameInput"},
* enter, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !codeActionMenuVisible && !editorReadonly && !renameInputVisible && !suggestWidgetVisible, args: {"command":"type","args":{"text":"\n"}},
* enter, kb-macro.wrap, when: false, args: {"command":"agentSession.rename"},
* enter, kb-macro.wrap, when: false, args: {"command":"debug.renameWatchExpression"},
* enter, kb-macro.wrap, when: false, args: {"command":"debug.setVariable"},
* enter, kb-macro.wrap, when: false, args: {"command":"remote.tunnel.label"},
* enter, kb-macro.wrap, when: false, args: {"command":"renameFile"},
* enter, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.renameActiveTab"},
* enter, kb-macro.wrap, when: fileMatchOrMatchFocus && kb-macro.active && searchViewletVisible, args: {"command":"search.action.openResult"},
* enter, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceIsFolder && !inputFocus, args: {"command":"explorer.openAndPassFocus"},
* enter, kb-macro.wrap, when: iconSelectBoxFocus && kb-macro.active, args: {"command":"iconSelectBox.selectFocused"},
* enter, kb-macro.wrap, when: inChat && kb-macro.active && !textInputFocus, args: {"command":"workbench.action.chat.editRequests"},
* enter, kb-macro.wrap, when: inDebugRepl && kb-macro.active && textInputFocus, args: {"command":"repl.action.acceptInput"},
* enter, kb-macro.wrap, when: inKeybindings && kb-macro.active && keybindingFocus && !whenFocus, args: {"command":"keybindings.editor.defineKeybinding"},
* enter, kb-macro.wrap, when: inKeybindings && kb-macro.active && whenFocus && !suggestWidgetVisible, args: {"command":"keybindings.editor.acceptWhenExpression"},
* enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* enter, kb-macro.wrap, when: inSettingsEditor && kb-macro.active && settingRowFocus, args: {"command":"settings.action.focusSettingControl"},
* enter, kb-macro.wrap, when: inSettingsEditor && kb-macro.active && settingsTocRowFocus, args: {"command":"settings.action.focusSettingsList"},
* enter, kb-macro.wrap, when: inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active && !config.inlineChat.askInChat || inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active && !inlineChatFileBelongsToChat || inlineChatHasEditsAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active && !config.inlineChat.askInChat && !inlineChatFileBelongsToChat || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active && !config.inlineChat.askInChat && activeEditor == 'workbench.editor.notebook' || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook' || inlineChatHasNotebookAgent && inlineChatInputHasText && inlineChatInputWidgetFocused && kb-macro.active && !config.inlineChat.askInChat && !inlineChatFileBelongsToChat && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat.submitInput"},
* enter, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !config.interactiveWindow.executeWithShiftEnter && !notebookCellListFocused && activeEditor == 'workbench.editor.repl', args: {"command":"repl.execute"},
* enter, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !config.interactiveWindow.executeWithShiftEnter && activeEditor == 'workbench.editor.interactive', args: {"command":"interactive.execute"},
* enter, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.select"},
* enter, kb-macro.wrap, when: kb-macro.active && listFocus && referenceSearchVisible && !inputFocus && !treeElementCanCollapse && !treeElementCanExpand && !treestickyScrollFocused, args: {"command":"revealReference"},
* enter, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && !editorHoverFocused && !inputFocus && !notebookOutputInputFocused, args: {"command":"notebook.cell.edit"},
* enter, kb-macro.wrap, when: kb-macro.active && notificationFocus, args: {"command":"notification.toggle"},
* enter, kb-macro.wrap, when: kb-macro.active && problemFocus, args: {"command":"problems.action.open"},
* enter, kb-macro.wrap, when: kb-macro.active && simpleSuggestWidgetExplicitlyInvoked && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetExplicitlyInvoked && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && simpleSuggestWidgetHasNavigated && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && simpleSuggestWidgetHasNavigated && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && !simpleSuggestWidgetFirstSuggestionFocused || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.selectionMode != 'partial' || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && !simpleSuggestWidgetFirstSuggestionFocused || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.selectionMode != 'partial', args: {"command":"workbench.action.terminal.acceptSelectedSuggestion"},
* enter, kb-macro.wrap, when: kb-macro.active && standaloneColorPickerFocused, args: {"command":"editor.action.insertColorWithStandaloneColorPicker"},
* enter, kb-macro.wrap, when: kb-macro.active && stickyScrollFocused, args: {"command":"editor.action.goToFocusedStickyScrollLine"},
* enter, kb-macro.wrap, when: kb-macro.active && terminalFindInputFocused && terminalHasBeenCreated || kb-macro.active && terminalFindInputFocused && terminalProcessSupported, args: {"command":"workbench.action.terminal.findPrevious"},
* enter, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.runOnEnter != 'never' || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.runOnEnter != 'never', args: {"command":"workbench.action.terminal.acceptSelectedSuggestionEnter"},
* enter, kb-macro.wrap, when: kb-macro.active && treestickyScrollFocused, args: {"command":"list.stickyScrollselect"},
* enter, kb-macro.wrap, when: kb-macro.active && webviewFindWidgetFocused && !editorFocus && activeEditor == 'WebviewEditor', args: {"command":"editor.action.webvieweditor.findNext"},
* enter, kb-macro.wrap, when: kb-macro.active && webviewFindWidgetFocused && !editorFocus && activeEditor == 'workbench.editor.extension', args: {"command":"editor.action.extensioneditor.findNext"},
* enter, keybindings.editor.acceptWhenExpression, when: inKeybindings && whenFocus && !suggestWidgetVisible,
* enter, keybindings.editor.defineKeybinding, when: inKeybindings && keybindingFocus && !whenFocus,
* enter, list.select, when: listFocus && !inputFocus && !treestickyScrollFocused,
* enter, list.stickyScrollselect, when: treestickyScrollFocused,
* enter, notebook.cell.edit, when: notebookCellListFocused && !editorHoverFocused && !inputFocus && !notebookOutputInputFocused,
* enter, notification.toggle, when: notificationFocus,
* enter, problems.action.open, when: problemFocus,
* enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* enter, repl.action.acceptInput, when: inDebugRepl && textInputFocus,
* enter, repl.execute, when: isCompositeNotebook && !config.interactiveWindow.executeWithShiftEnter && !notebookCellListFocused && activeEditor == 'workbench.editor.repl',
* enter, revealReference, when: listFocus && referenceSearchVisible && !inputFocus && !treeElementCanCollapse && !treeElementCanExpand && !treestickyScrollFocused,
* enter, search.action.openResult, when: fileMatchOrMatchFocus && searchViewletVisible,
* enter, settings.action.focusSettingControl, when: inSettingsEditor && settingRowFocus,
* enter, settings.action.focusSettingsList, when: inSettingsEditor && settingsTocRowFocus,
* enter, workbench.action.browser.findNext, when: browserFindWidgetFocused && activeEditor == 'workbench.editor.browser',
* enter, workbench.action.chat.editRequests, when: inChat && !textInputFocus,
* enter, workbench.action.chat.queueMessage, when: chatSessionRequestInProgress && inChatInput && chatInputHasText && chatSessionRequestInProgress && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st' && config.chat.requestQueuing.defaultAction != 'steer' || chatInputHasText && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's',
* enter, workbench.action.chat.steerWithMessage, when: chatInputHasText && inChatInput && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatSessionRequestInProgress && inChatInput && config.chat.requestQueuing.defaultAction == 'steer' && chatInputHasText && chatSessionRequestInProgress && chatEditingSentRequest != 'q' && chatEditingSentRequest != 's' && chatEditingSentRequest != 'st' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's' || chatInputHasText && chatSessionRequestInProgress && inChatInput && chatEditingSentRequest == 'q' && chatEditingSentRequest == 'st' && chatEditingSentRequest != 's',
* enter, workbench.action.chat.submit, when: chatInputHasText && chatSessionOptionsValid && inChatInput && !chatSessionRequestInProgress && !withinEditSessionDiff,
* enter, workbench.action.terminal.acceptSelectedSuggestion, when: simpleSuggestWidgetExplicitlyInvoked && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || simpleSuggestWidgetExplicitlyInvoked && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible || simpleSuggestWidgetHasFocusedSuggestion && simpleSuggestWidgetHasNavigated && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || simpleSuggestWidgetHasFocusedSuggestion && simpleSuggestWidgetHasNavigated && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible || simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && !simpleSuggestWidgetFirstSuggestionFocused || simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.selectionMode != 'partial' || simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && !simpleSuggestWidgetFirstSuggestionFocused || simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.selectionMode != 'partial',
* enter, workbench.action.terminal.acceptSelectedSuggestionEnter, when: terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.runOnEnter != 'never' || terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && config.terminal.integrated.suggest.runOnEnter != 'never',
* enter, workbench.action.terminal.findPrevious, when: terminalFindInputFocused && terminalHasBeenCreated || terminalFindInputFocused && terminalProcessSupported,
* escape escape, kb-macro.wrap, when: inZenMode && kb-macro.active, args: {"command":"workbench.action.exitZenMode"},
* escape escape, workbench.action.exitZenMode, when: inZenMode,
* escape, agentSession.exitAgentSessionProjection, when: chatInAgentSessionProjection && chatIsEnabled,
* escape, breadcrumbs.selectEditor, when: breadcrumbsActive && breadcrumbsVisible,
* escape, cancelLinkedEditingInput, when: LinkedEditingInputVisible && editorTextFocus,
* escape, cancelRenameInput, when: editorFocus && renameInputVisible,
* escape, cancelSelection, when: editorHasSelection && textInputFocus,
* escape, clearFilterCodeActionWidget, when: codeActionMenuFilterFocused && codeActionMenuVisible,
* escape, closeBreakpointWidget, when: breakpointWidgetVisible && textInputFocus,
* escape, closeFindWidget, when: editorFocus && findWidgetVisible && !isComposing,
* escape, closeMarkersNavigation, when: editorFocus && markersNavigationVisible,
* escape, closeParameterHints, when: editorFocus && parameterHintsVisible,
* escape, closeQuickDiff, when: dirtyDiffVisible,
* escape, closeReferenceSearch, when: editorTextFocus && referenceSearchVisible && !config.editor.stablePeek || referenceSearchVisible && !config.editor.stablePeek && !inputFocus,
* escape, closeReferenceSearch, when: inReferenceSearchEditor && !config.editor.stablePeek,
* escape, closeReplaceInFilesWidget, when: replaceInputBoxFocus && searchViewletVisible,
* escape, commentsClearFilterText, when: commentsFilterFocus,
* escape, diffEditor.exitCompareMove, when: comparingMovedCode" }
* escape, editor.action.cancelSelectionAnchor, when: editorTextFocus && selectionAnchorSet,
* escape, editor.action.hideColorPicker, when: standaloneColorPickerVisible,
* escape, editor.action.inlineSuggest.hide, when: inInlineEditsPreviewEditor,
* escape, editor.action.inlineSuggest.hide, when: inlineEditIsVisible || inlineSuggestionVisible,
* escape, editor.action.selectEditor, when: stickyScrollFocused,
* escape, editor.action.webvieweditor.hideFind, when: webviewFindWidgetVisible && !editorFocus && activeEditor == 'WebviewEditor',
* escape, editor.cancelOperation, when: cancellableOperation,
* escape, editor.closeCallHierarchy, when: callHierarchyVisible && !config.editor.stablePeek,
* escape, editor.closeTestPeek, when: testing.isInPeek && !config.editor.stablePeek || testing.isPeekVisible && !config.editor.stablePeek,
* escape, editor.closeTypeHierarchy, when: typeHierarchyVisible && !config.editor.stablePeek,
* escape, editor.debug.action.closeExceptionWidget, when: exceptionWidgetVisible,
* escape, editor.gotoNextSymbolFromResult.cancel, when: hasSymbols,
* escape, editor.hideDropWidget, when: dropWidgetVisible,
* escape, editor.hidePasteWidget, when: pasteWidgetVisible,
* escape, filesExplorer.cancelCut, when: explorerResourceCut && filesExplorerFocus && foldersViewVisible && !inputFocus,
* escape, github.copilot.nes.captureExpected.abort, when: copilotNesCaptureMode && editorTextFocus,
* escape, hideCodeActionWidget, when: codeActionMenuVisible && kb-macro.active,
* escape, hideCodeActionWidget, when: codeActionMenuVisible,
* escape, hideSuggestWidget, when: suggestWidgetVisible && textInputFocus,
* escape, inlayHints.stopReadingLineWithHint, when: isReadingLineWithInlayHints,
* escape, inlineChat.dismissEditorAffordance, when: editorTextFocus && inlineChatAffordanceVisible && config.inlineChat.affordance == 'editor',
* escape, inlineChat.hideInput, when: inlineChatHasEditsAgent && inlineChatInputWidgetFocused || inlineChatHasNotebookAgent && inlineChatInputWidgetFocused && activeEditor == 'workbench.editor.notebook',
* escape, inlineChat2.cancel, when: chatEdits.isRequestInProgress && chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible || chatEdits.isRequestInProgress && editorFocus && inlineChatHasEditsAgent && inlineChatVisible || chatEdits.isRequestInProgress && chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook' || chatEdits.isRequestInProgress && editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook',
* escape, inlineChat2.close, when: chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible || chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.hasEditorModifications || editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.hasEditorModifications && activeEditor == 'workbench.editor.notebook',
* escape, inlineChat2.undo, when: chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && config.inlineChat.renderMode == 'hover' || chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && activeEditor == 'workbench.editor.notebook' && config.inlineChat.renderMode == 'hover' || editorFocus && inlineChatHasEditsAgent && inlineChatVisible && !chatEdits.hasEditorModifications && config.inlineChat.renderMode == 'hover' || editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && !chatEdits.hasEditorModifications && activeEditor == 'workbench.editor.notebook' && config.inlineChat.renderMode == 'hover',
* escape, kb-macro.abortPlayback, when: kb-macro.playing,
* escape, kb-macro.wrap, when: LinkedEditingInputVisible && editorTextFocus && kb-macro.active, args: {"command":"cancelLinkedEditingInput"},
* escape, kb-macro.wrap, when: bannerFocused && kb-macro.active, args: {"command":"workbench.banner.focusBanner"},
* escape, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.selectEditor"},
* escape, kb-macro.wrap, when: breakpointWidgetVisible && kb-macro.active && textInputFocus, args: {"command":"closeBreakpointWidget"},
* escape, kb-macro.wrap, when: browserElementSelectionActive && browserHasUrl && chatIsEnabled && config.chat.sendElementsToChat.enabled && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.addElementToChat"},
* escape, kb-macro.wrap, when: browserFindWidgetVisible && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.hideFind"},
* escape, kb-macro.wrap, when: callHierarchyVisible && kb-macro.active && !config.editor.stablePeek, args: {"command":"editor.closeCallHierarchy"},
* escape, kb-macro.wrap, when: cancellableOperation && kb-macro.active, args: {"command":"editor.cancelOperation"},
* escape, kb-macro.wrap, when: chatEdits.isRequestInProgress && chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active || chatEdits.isRequestInProgress && editorFocus && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active || chatEdits.isRequestInProgress && chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && activeEditor == 'workbench.editor.notebook' || chatEdits.isRequestInProgress && editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat2.cancel"},
* escape, kb-macro.wrap, when: chatInAgentSessionProjection && chatIsEnabled && kb-macro.active, args: {"command":"agentSession.exitAgentSessionProjection"},
* escape, kb-macro.wrap, when: chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active && config.inlineChat.renderMode == 'hover' || chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && activeEditor == 'workbench.editor.notebook' && config.inlineChat.renderMode == 'hover' || editorFocus && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active && !chatEdits.hasEditorModifications && config.inlineChat.renderMode == 'hover' || editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && !chatEdits.hasEditorModifications && activeEditor == 'workbench.editor.notebook' && config.inlineChat.renderMode == 'hover', args: {"command":"inlineChat2.undo"},
* escape, kb-macro.wrap, when: chatInputHasFocus && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active || chatInputHasFocus && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && activeEditor == 'workbench.editor.notebook' || editorFocus && inlineChatHasEditsAgent && inlineChatVisible && kb-macro.active && !chatEdits.hasEditorModifications || editorFocus && inlineChatHasNotebookAgent && inlineChatVisible && kb-macro.active && !chatEdits.hasEditorModifications && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat2.close"},
* escape, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatFocus && terminalChatVisible || chatIsEnabled && kb-macro.active && terminalChatVisible && terminalFocus, args: {"command":"workbench.action.terminal.chat.close"},
* escape, kb-macro.wrap, when: chatSessionCurrentlyEditing && inChatInput && kb-macro.active && !editorHasMultipleSelections && !editorHasSelection && !editorHoverVisible || chatSessionCurrentlyEditingInput && inChatInput && kb-macro.active && !editorHasMultipleSelections && !editorHasSelection && !editorHoverVisible, args: {"command":"workbench.edit.chat.cancel"},
* escape, kb-macro.wrap, when: codeActionMenuFilterFocused && codeActionMenuVisible && kb-macro.active, args: {"command":"clearFilterCodeActionWidget"},
* escape, kb-macro.wrap, when: commentEditorFocused && kb-macro.active || commentFocused && kb-macro.active, args: {"command":"workbench.action.hideComment"},
* escape, kb-macro.wrap, when: commentsFilterFocus && kb-macro.active, args: {"command":"commentsClearFilterText"},
* escape, kb-macro.wrap, when: comparingMovedCode && kb-macro.active, args: {"command":"diffEditor.exitCompareMove"},
* escape, kb-macro.wrap, when: config.notebook.multiCursor.enabled && isNotebookMultiSelect && kb-macro.active && activeEditor == 'workbench.editor.notebook', args: {"command":"noteMultiCursor.exit"},
* escape, kb-macro.wrap, when: dirtyDiffVisible && kb-macro.active, args: {"command":"closeQuickDiff"},
* escape, kb-macro.wrap, when: dropWidgetVisible && kb-macro.active, args: {"command":"editor.hideDropWidget"},
* escape, kb-macro.wrap, when: editorDictation.inProgress && kb-macro.active, args: {"command":"workbench.action.editorDictation.stop"},
* escape, kb-macro.wrap, when: editorFocus && editorPartModal && kb-macro.active, args: {"command":"workbench.action.closeModalEditor"},
* escape, kb-macro.wrap, when: editorFocus && findWidgetVisible && kb-macro.active && !isComposing, args: {"command":"closeFindWidget"},
* escape, kb-macro.wrap, when: editorFocus && kb-macro.active && markersNavigationVisible, args: {"command":"closeMarkersNavigation"},
* escape, kb-macro.wrap, when: editorFocus && kb-macro.active && parameterHintsVisible, args: {"command":"closeParameterHints"},
* escape, kb-macro.wrap, when: editorFocus && kb-macro.active && renameInputVisible, args: {"command":"cancelRenameInput"},
* escape, kb-macro.wrap, when: editorHasMultipleSelections && kb-macro.active && textInputFocus, args: {"command":"removeSecondaryCursors"},
* escape, kb-macro.wrap, when: editorHasSelection && kb-macro.active && textInputFocus, args: {"command":"cancelSelection"},
* escape, kb-macro.wrap, when: editorPartModal && kb-macro.active && !editorFocus, args: {"command":"workbench.action.closeModalEditor"},
* escape, kb-macro.wrap, when: editorTextFocus && inlineChatAffordanceVisible && kb-macro.active && config.inlineChat.affordance == 'editor', args: {"command":"inlineChat.dismissEditorAffordance"},
* escape, kb-macro.wrap, when: editorTextFocus && kb-macro.active && referenceSearchVisible && !config.editor.stablePeek || kb-macro.active && referenceSearchVisible && !config.editor.stablePeek && !inputFocus, args: {"command":"closeReferenceSearch"},
* escape, kb-macro.wrap, when: editorTextFocus && kb-macro.active && selectionAnchorSet, args: {"command":"editor.action.cancelSelectionAnchor"},
* escape, kb-macro.wrap, when: exceptionWidgetVisible && kb-macro.active, args: {"command":"editor.debug.action.closeExceptionWidget"},
* escape, kb-macro.wrap, when: explorerResourceCut && filesExplorerFocus && foldersViewVisible && kb-macro.active && !inputFocus, args: {"command":"filesExplorer.cancelCut"},
* escape, kb-macro.wrap, when: findWidgetVisible && kb-macro.active && notebookEditorFocused, args: {"command":"notebook.hideFind"},
* escape, kb-macro.wrap, when: hasSymbols && kb-macro.active, args: {"command":"editor.gotoNextSymbolFromResult.cancel"},
* escape, kb-macro.wrap, when: inInlineEditsPreviewEditor && kb-macro.active, args: {"command":"editor.action.inlineSuggest.hide","record":"side-effect"},
* escape, kb-macro.wrap, when: inKeybindings && inKeybindingsSearch && kb-macro.active && keybindingsSearchHasValue, args: {"command":"keybindings.editor.clearSearchResults"},
* escape, kb-macro.wrap, when: inKeybindings && kb-macro.active && whenFocus && !suggestWidgetVisible, args: {"command":"keybindings.editor.rejectWhenExpression"},
* escape, kb-macro.wrap, when: inModelsEditor && inModelsSearch && kb-macro.active, args: {"command":"chat.models.action.clearSearchResults"},
* escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* escape, kb-macro.wrap, when: inQuickOpen && kb-macro.active, args: {"command":"workbench.action.closeQuickOpen"},
* escape, kb-macro.wrap, when: inReferenceSearchEditor && kb-macro.active && !config.editor.stablePeek, args: {"command":"closeReferenceSearch"},
* escape, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"search.action.focusQueryEditorWidget"},
* escape, kb-macro.wrap, when: inSettingsEditor && inSettingsSearch && kb-macro.active, args: {"command":"settings.action.clearSearchResults"},
* escape, kb-macro.wrap, when: inSettingsEditor && kb-macro.active && !inSettingsJSONEditor && !inSettingsSearch, args: {"command":"settings.action.focusLevelUp"},
* escape, kb-macro.wrap, when: inSnippetMode && kb-macro.active && textInputFocus, args: {"command":"leaveSnippet","record":"side-effect"},
* escape, kb-macro.wrap, when: inWelcome && kb-macro.active && activeEditor == 'gettingStartedPage', args: {"command":"welcome.goBack"},
* escape, kb-macro.wrap, when: inlineChatHasEditsAgent && inlineChatInputWidgetFocused && kb-macro.active || inlineChatHasNotebookAgent && inlineChatInputWidgetFocused && kb-macro.active && activeEditor == 'workbench.editor.notebook', args: {"command":"inlineChat.hideInput"},
* escape, kb-macro.wrap, when: inlineEditIsVisible && kb-macro.active || inlineSuggestionVisible && kb-macro.active, args: {"command":"editor.action.inlineSuggest.hide","record":"side-effect"},
* escape, kb-macro.wrap, when: inputFocus && kb-macro.active && notebookEditorFocused && !editorHasMultipleSelections && !editorHasSelection && !editorHoverVisible && !inlineChatFocused, args: {"command":"notebook.cell.quitEdit"},
* escape, kb-macro.wrap, when: isReadingLineWithInlayHints && kb-macro.active, args: {"command":"inlayHints.stopReadingLineWithHint"},
* escape, kb-macro.wrap, when: kb-macro.active && listFocus && listHasSelectionOrFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.clear"},
* escape, kb-macro.wrap, when: kb-macro.active && listFocus && searchViewletVisible && !inputFocus && !treestickyScrollFocused && searchState != '0', args: {"command":"search.action.cancel"},
* escape, kb-macro.wrap, when: kb-macro.active && listFocus && treeFindOpen, args: {"command":"list.closeFind"},
* escape, kb-macro.wrap, when: kb-macro.active && messageVisible, args: {"command":"leaveEditorMessage"},
* escape, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && notebookOutputFocused, args: {"command":"notebook.cell.quitEdit"},
* escape, kb-macro.wrap, when: kb-macro.active && notificationCenterVisible, args: {"command":"notifications.hideList"},
* escape, kb-macro.wrap, when: kb-macro.active && notificationFocus && notificationToastsVisible, args: {"command":"notifications.hideToasts"},
* escape, kb-macro.wrap, when: kb-macro.active && notificationToastsVisible, args: {"command":"notifications.hideToasts"},
* escape, kb-macro.wrap, when: kb-macro.active && pasteWidgetVisible, args: {"command":"editor.hidePasteWidget"},
* escape, kb-macro.wrap, when: kb-macro.active && problemsFilterFocus, args: {"command":"problems.action.clearFilterText"},
* escape, kb-macro.wrap, when: kb-macro.active && replaceInputBoxFocus && searchViewletVisible, args: {"command":"closeReplaceInFilesWidget"},
* escape, kb-macro.wrap, when: kb-macro.active && scmInputHasValidationMessage && scmRepository, args: {"command":"scm.clearValidation"},
* escape, kb-macro.wrap, when: kb-macro.active && scmRepository && !editorHasSelection && !inlineSuggestionVisible && !scmInputHasValidationMessage && !suggestWidgetVisible, args: {"command":"scm.clearInput"},
* escape, kb-macro.wrap, when: kb-macro.active && scopedChatSynthesisInProgress && textToSpeechInProgress, args: {"command":"workbench.action.speech.stopReadAloud"},
* escape, kb-macro.wrap, when: kb-macro.active && scopedChatSynthesisInProgress, args: {"command":"workbench.action.chat.stopReadChatItemAloud"},
* escape, kb-macro.wrap, when: kb-macro.active && standaloneColorPickerVisible, args: {"command":"editor.action.hideColorPicker"},
* escape, kb-macro.wrap, when: kb-macro.active && statusBarFocused, args: {"command":"workbench.statusBar.clearFocus"},
* escape, kb-macro.wrap, when: kb-macro.active && stickyScrollFocused, args: {"command":"editor.action.selectEditor"},
* escape, kb-macro.wrap, when: kb-macro.active && suggestWidgetVisible && textInputFocus, args: {"command":"hideSuggestWidget","record":"side-effect"},
* escape, kb-macro.wrap, when: kb-macro.active && terminalDictationInProgress, args: {"command":"workbench.action.terminal.stopVoice"},
* escape, kb-macro.wrap, when: kb-macro.active && terminalFindVisible && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.hideFind"},
* escape, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.hideSuggestWidget"},
* escape, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && terminalTextSelected && !terminalFindVisible || kb-macro.active && terminalFocusInAny && terminalProcessSupported && terminalTextSelected && !terminalFindVisible, args: {"command":"workbench.action.terminal.clearSelection"},
* escape, kb-macro.wrap, when: kb-macro.active && testing.isInPeek && !config.editor.stablePeek || kb-macro.active && testing.isPeekVisible && !config.editor.stablePeek, args: {"command":"editor.closeTestPeek"},
* escape, kb-macro.wrap, when: kb-macro.active && typeHierarchyVisible && !config.editor.stablePeek, args: {"command":"editor.closeTypeHierarchy"},
* escape, kb-macro.wrap, when: kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || kb-macro.active && voiceChatInProgress && scopedVoiceChatInProgress == 'view', args: {"command":"workbench.action.chat.stopListening"},
* escape, kb-macro.wrap, when: kb-macro.active && webviewFindWidgetVisible && !editorFocus && activeEditor == 'WebviewEditor', args: {"command":"editor.action.webvieweditor.hideFind"},
* escape, keybindings.editor.clearSearchResults, when: inKeybindings && inKeybindingsSearch && keybindingsSearchHasValue,
* escape, keybindings.editor.rejectWhenExpression, when: inKeybindings && whenFocus && !suggestWidgetVisible,
* escape, leaveEditorMessage, when: messageVisible,
* escape, leaveSnippet, when: inSnippetMode && textInputFocus,
* escape, list.clear, when: listFocus && listHasSelectionOrFocus && !inputFocus && !treestickyScrollFocused,
* escape, list.closeFind, when: listFocus && treeFindOpen,
* escape, noteMultiCursor.exit, when: config.notebook.multiCursor.enabled && isNotebookMultiSelect && activeEditor == 'workbench.editor.notebook',
* escape, notebook.cell.quitEdit, when: inputFocus && notebookEditorFocused && !editorHasMultipleSelections && !editorHasSelection && !editorHoverVisible && !inlineChatFocused,
* escape, notebook.cell.quitEdit, when: notebookEditorFocused && notebookOutputFocused,
* escape, notebook.hideFind, when: findWidgetVisible && notebookEditorFocused,
* escape, notifications.hideList, when: notificationCenterVisible,
* escape, notifications.hideToasts, when: notificationFocus && notificationToastsVisible,
* escape, notifications.hideToasts, when: notificationToastsVisible,
* escape, problems.action.clearFilterText, when: problemsFilterFocus,
* escape, quickInput.hide, when: inQuickInput,
* escape, removeSecondaryCursors, when: editorHasMultipleSelections && textInputFocus,
* escape, scm.clearInput, when: scmRepository && !editorHasSelection && !inlineSuggestionVisible && !scmInputHasValidationMessage && !suggestWidgetVisible,
* escape, scm.clearValidation, when: scmInputHasValidationMessage && scmRepository,
* escape, search.action.cancel, when: listFocus && searchViewletVisible && !inputFocus && !treestickyScrollFocused && searchState != '0',
* escape, search.action.focusQueryEditorWidget, when: inSearchEditor,
* escape, settings.action.clearSearchResults, when: inSettingsEditor && inSettingsSearch,
* escape, settings.action.focusLevelUp, when: inSettingsEditor && !inSettingsJSONEditor && !inSettingsSearch,
* escape, welcome.goBack, when: inWelcome && activeEditor == 'gettingStartedPage',
* escape, workbench.action.browser.addElementToChat, when: browserElementSelectionActive && browserHasUrl && chatIsEnabled && config.chat.sendElementsToChat.enabled && !browserHasError && activeEditor == 'workbench.editor.browser',
* escape, workbench.action.browser.hideFind, when: browserFindWidgetVisible && activeEditor == 'workbench.editor.browser',
* escape, workbench.action.chat.stopListening, when: voiceChatInProgress && scopedVoiceChatInProgress == 'editor' || voiceChatInProgress && scopedVoiceChatInProgress == 'inline' || voiceChatInProgress && scopedVoiceChatInProgress == 'quick' || voiceChatInProgress && scopedVoiceChatInProgress == 'view',
* escape, workbench.action.chat.stopReadChatItemAloud, when: scopedChatSynthesisInProgress,
* escape, workbench.action.closeModalEditor, when: editorFocus && editorPartModal,
* escape, workbench.action.closeModalEditor, when: editorPartModal && !editorFocus,
* escape, workbench.action.closeQuickOpen, when: inQuickOpen,
* escape, workbench.action.editorDictation.stop, when: editorDictation.inProgress,
* escape, workbench.action.hideComment, when: commentEditorFocused || commentFocused,
* escape, workbench.action.speech.stopReadAloud, when: scopedChatSynthesisInProgress && textToSpeechInProgress,
* escape, workbench.action.terminal.chat.close, when: chatIsEnabled && terminalChatFocus && terminalChatVisible || chatIsEnabled && terminalChatVisible && terminalFocus,
* escape, workbench.action.terminal.clearSelection, when: terminalFocusInAny && terminalHasBeenCreated && terminalTextSelected && !terminalFindVisible || terminalFocusInAny && terminalProcessSupported && terminalTextSelected && !terminalFindVisible,
* escape, workbench.action.terminal.hideFind, when: terminalFindVisible && terminalFocusInAny && terminalHasBeenCreated || terminalFindVisible && terminalFocusInAny && terminalProcessSupported,
* escape, workbench.action.terminal.hideSuggestWidget, when: terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* escape, workbench.action.terminal.stopVoice, when: terminalDictationInProgress,
* escape, workbench.banner.focusBanner, when: bannerFocused,
* escape, workbench.edit.chat.cancel, when: chatSessionCurrentlyEditing && inChatInput && !editorHasMultipleSelections && !editorHasSelection && !editorHoverVisible || chatSessionCurrentlyEditingInput && inChatInput && !editorHasMultipleSelections && !editorHasSelection && !editorHoverVisible,
* escape, workbench.statusBar.clearFocus, when: statusBarFocused,
* f1, workbench.action.showCommands,
* f1, workbench.action.showCommands, when: kb-macro.active,
* f2, agentSession.rename, when: agentSessionsViewerFocused && !agentSessionHasMultipleSelected && chatSessionType == 'local',
* f2, debug.renameWatchExpression, when: watchExpressionsFocused,
* f2, debug.setVariable, when: variablesFocused,
* f2, editor.action.rename, when: editorHasRenameProvider && editorTextFocus && !editorReadonly,
* f2, kb-macro.wrap, when: agentSessionsViewerFocused && kb-macro.active && !agentSessionHasMultipleSelected && chatSessionType == 'local', args: {"command":"agentSession.rename"},
* f2, kb-macro.wrap, when: editorHasRenameProvider && editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.rename"},
* f2, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceIsRoot && !explorerResourceReadonly && !inputFocus, args: {"command":"renameFile"},
* f2, kb-macro.wrap, when: kb-macro.active && terminalHasBeenCreated && terminalTabsFocus && terminalTabsSingularSelection || kb-macro.active && terminalProcessSupported && terminalTabsFocus && terminalTabsSingularSelection, args: {"command":"workbench.action.terminal.renameActiveTab"},
* f2, kb-macro.wrap, when: kb-macro.active && tunnelViewFocus && tunnelType == 'Forwarded' && tunnelViewMultiSelection == 'undefined', args: {"command":"remote.tunnel.label"},
* f2, kb-macro.wrap, when: kb-macro.active && variablesFocused, args: {"command":"debug.setVariable"},
* f2, kb-macro.wrap, when: kb-macro.active && watchExpressionsFocused, args: {"command":"debug.renameWatchExpression"},
* f2, remote.tunnel.label, when: tunnelViewFocus && tunnelType == 'Forwarded' && tunnelViewMultiSelection == 'undefined',
* f2, renameFile, when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsRoot && !explorerResourceReadonly && !inputFocus,
* f2, workbench.action.terminal.renameActiveTab, when: terminalHasBeenCreated && terminalTabsFocus && terminalTabsSingularSelection || terminalProcessSupported && terminalTabsFocus && terminalTabsSingularSelection,
* f3, editor.action.nextMatchFindAction, when: editorFocus,
* f3, kb-macro.wrap, when: browserFindWidgetVisible && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.findNext"},
* f3, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.nextMatchFindAction"},
* f3, kb-macro.wrap, when: findWidgetVisible && kb-macro.active && notebookEditorFocused, args: {"command":"notebook.findNext.fromWidget"},
* f3, kb-macro.wrap, when: kb-macro.active && listFocus && listSupportsFind, args: {"command":"list.find"},
* f3, kb-macro.wrap, when: kb-macro.active && terminalFindFocused && terminalHasBeenCreated || kb-macro.active && terminalFindFocused && terminalProcessSupported || kb-macro.active && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.findNext"},
* f3, kb-macro.wrap, when: kb-macro.active && view == 'workbench.panel.repl.view', args: {"command":"list.find.replInputFocus"},
* f3, list.find, when: listFocus && listSupportsFind,
* f3, list.find.replInputFocus, when: view == 'workbench.panel.repl.view',
* f3, notebook.findNext.fromWidget, when: findWidgetVisible && notebookEditorFocused,
* f3, workbench.action.browser.findNext, when: browserFindWidgetVisible && activeEditor == 'workbench.editor.browser',
* f3, workbench.action.terminal.findNext, when: terminalFindFocused && terminalHasBeenCreated || terminalFindFocused && terminalProcessSupported || terminalFocusInAny && terminalHasBeenCreated || terminalFocusInAny && terminalProcessSupported,
* f4, goToNextReference, when: inReferenceSearchEditor || referenceSearchVisible,
* f4, kb-macro.wrap, when: hasSearchResult && kb-macro.active || inSearchEditor && kb-macro.active, args: {"command":"search.action.focusNextSearchResult"},
* f4, kb-macro.wrap, when: inReferenceSearchEditor && kb-macro.active || kb-macro.active && referenceSearchVisible, args: {"command":"goToNextReference"},
* f4, kb-macro.wrap, when: kb-macro.active && reference-list.hasResult && references-view.canNavigate, args: {"command":"references-view.next"},
* f4, references-view.next, when: reference-list.hasResult && references-view.canNavigate,
* f4, search.action.focusNextSearchResult, when: hasSearchResult || inSearchEditor,
* f5, debug.openView, when: !debuggersAvailable,
* f5, kb-macro.wrap, when: browserFocused && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.reload"},
* f5, kb-macro.wrap, when: debuggersAvailable && kb-macro.active && debugState == 'inactive', args: {"command":"workbench.action.debug.start"},
* f5, kb-macro.wrap, when: kb-macro.active && !debuggersAvailable, args: {"command":"debug.openView"},
* f5, kb-macro.wrap, when: kb-macro.active && debugState == 'stopped', args: {"command":"workbench.action.debug.continue"},
* f5, workbench.action.browser.reload, when: browserFocused && activeEditor == 'workbench.editor.browser',
* f5, workbench.action.debug.continue, when: debugState == 'stopped',
* f5, workbench.action.debug.start, when: debuggersAvailable && debugState == 'inactive',
* f6, kb-macro.wrap, when: kb-macro.active && debugState == 'running', args: {"command":"workbench.action.debug.pause"},
* f6, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusNextPart"},
* f6, workbench.action.debug.pause, when: debugState == 'running',
* f6, workbench.action.focusNextPart,
* f7, chatEditor.action.showAccessibleDiffView, when: accessibilityModeEnabled && chatEdits.hasEditorModifications && editorFocus && !chatEdits.isCurrentlyBeingModified,
* f7, editor.action.accessibleDiffViewer.next, when: isInDiffEditor,
* f7, editor.action.wordHighlight.next, when: editorTextFocus && hasWordHighlights,
* f7, kb-macro.wrap, when: accessibilityModeEnabled && chatEdits.hasEditorModifications && editorFocus && kb-macro.active && !chatEdits.isCurrentlyBeingModified, args: {"command":"chatEditor.action.showAccessibleDiffView"},
* f7, kb-macro.wrap, when: editorTextFocus && hasWordHighlights && kb-macro.active, args: {"command":"editor.action.wordHighlight.next"},
* f7, kb-macro.wrap, when: isInDiffEditor && kb-macro.active, args: {"command":"editor.action.accessibleDiffViewer.next"},
* f8, editor.action.marker.nextInFiles, when: editorFocus,
* f8, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.marker.nextInFiles"},
* f9, editor.debug.action.toggleBreakpoint, when: debuggersAvailable && disassemblyViewFocus || debuggersAvailable && editorTextFocus,
* f9, kb-macro.wrap, when: debuggersAvailable && disassemblyViewFocus && kb-macro.active || debuggersAvailable && editorTextFocus && kb-macro.active, args: {"command":"editor.debug.action.toggleBreakpoint"},
* f10, extension.node-debug.startWithStopOnEntry, when: !inDebugMode && debugConfigurationType == 'node' || !inDebugMode && debugConfigurationType == 'pwa-extensionHost' || !inDebugMode && debugConfigurationType == 'pwa-node',
* f10, kb-macro.wrap, when: kb-macro.active && !inDebugMode && debugConfigurationType == 'node' || kb-macro.active && !inDebugMode && debugConfigurationType == 'pwa-extensionHost' || kb-macro.active && !inDebugMode && debugConfigurationType == 'pwa-node', args: {"command":"extension.node-debug.startWithStopOnEntry"},
* f10, kb-macro.wrap, when: kb-macro.active && debugState == 'stopped', args: {"command":"workbench.action.debug.stepOver"},
* f10, workbench.action.debug.stepOver, when: debugState == 'stopped',
* f11, extension.node-debug.startWithStopOnEntry, when: !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'node' || !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'pwa-extensionHost' || !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'pwa-node',
* f11, kb-macro.wrap, when: kb-macro.active && !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'node' || kb-macro.active && !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'pwa-extensionHost' || kb-macro.active && !inDebugMode && activeViewlet == 'workbench.view.debug' && debugConfigurationType == 'pwa-node', args: {"command":"extension.node-debug.startWithStopOnEntry"},
* f11, kb-macro.wrap, when: kb-macro.active && !isIOS, args: {"command":"workbench.action.toggleFullScreen"},
* f11, kb-macro.wrap, when: kb-macro.active && debugState != 'inactive', args: {"command":"workbench.action.debug.stepInto"},
* f11, workbench.action.debug.stepInto, when: debugState != 'inactive',
* f11, workbench.action.toggleFullScreen, when: !isIOS,
* f12, editor.action.revealDefinition, when: editorHasDefinitionProvider && editorTextFocus,
* f12, editor.gotoNextSymbolFromResult, when: hasSymbols,
* f12, goToNextReference, when: inReferenceSearchEditor || referenceSearchVisible,
* f12, kb-macro.wrap, when: browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.toggleDevTools"},
* f12, kb-macro.wrap, when: editorHasDefinitionProvider && editorTextFocus && kb-macro.active, args: {"command":"editor.action.revealDefinition"},
* f12, kb-macro.wrap, when: hasSymbols && kb-macro.active, args: {"command":"editor.gotoNextSymbolFromResult"},
* f12, kb-macro.wrap, when: inReferenceSearchEditor && kb-macro.active || kb-macro.active && referenceSearchVisible, args: {"command":"goToNextReference"},
* f12, workbench.action.browser.toggleDevTools, when: browserHasUrl && !browserHasError && activeEditor == 'workbench.editor.browser',
* home, cursorHome, when: textInputFocus,
* home, editor.action.goToTopHover, when: editorHoverFocused,
* home, firstCompressedFolder, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && !explorerViewletCompressedFirstFocus && !inputFocus,
* home, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.goToTopHover"},
* home, kb-macro.wrap, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerViewletCompressedFirstFocus && !inputFocus, args: {"command":"firstCompressedFolder"},
* home, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusFirst"},
* home, kb-macro.wrap, when: kb-macro.active && notificationFocus && notificationToastsVisible, args: {"command":"notifications.focusFirstToast"},
* home, kb-macro.wrap, when: kb-macro.active && statusBarFocused, args: {"command":"workbench.statusBar.focusFirst"},
* home, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorHome"},
* home, list.focusFirst, when: listFocus && !inputFocus && !treestickyScrollFocused,
* home, notifications.focusFirstToast, when: notificationFocus && notificationToastsVisible,
* home, workbench.statusBar.focusFirst, when: statusBarFocused,
* insert, editor.action.toggleOvertypeInsertMode,
* insert, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.toggleOvertypeInsertMode"},
* left, breadcrumbs.focusPrevious, when: breadcrumbsActive && breadcrumbsVisible,
* left, collapseSectionCodeAction, when: codeActionMenuVisible && !codeActionMenuFilterFocused,
* left, cursorLeft, when: textInputFocus,
* left, editor.action.scrollLeftHover, when: editorHoverFocused,
* left, iconSelectBox.focusPrevious, when: iconSelectBoxFocus && iconSelectBoxInputEmpty || iconSelectBoxFocus && !iconSelectBoxInputFocus,
* left, kb-macro.wrap, when: bannerFocused && kb-macro.active, args: {"command":"workbench.banner.focusPreviousAction"},
* left, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.focusPrevious"},
* left, kb-macro.wrap, when: codeActionMenuVisible && kb-macro.active && !codeActionMenuFilterFocused, args: {"command":"collapseSectionCodeAction"},
* left, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.scrollLeftHover"},
* left, kb-macro.wrap, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerViewletCompressedFirstFocus && !inputFocus, args: {"command":"previousCompressedFolder"},
* left, kb-macro.wrap, when: iconSelectBoxFocus && iconSelectBoxInputEmpty && kb-macro.active || iconSelectBoxFocus && kb-macro.active && !iconSelectBoxInputFocus, args: {"command":"iconSelectBox.focusPrevious"},
* left, kb-macro.wrap, when: inSettingsEditor && kb-macro.active && settingRowFocus, args: {"command":"settings.action.focusTOC"},
* left, kb-macro.wrap, when: kb-macro.active && listFocus && treeElementCanCollapse && !inputFocus && !treestickyScrollFocused || kb-macro.active && listFocus && treeElementHasParent && !inputFocus && !treestickyScrollFocused, args: {"command":"list.collapse"},
* left, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.fold"},
* left, kb-macro.wrap, when: kb-macro.active && notificationFocus, args: {"command":"notification.collapse"},
* left, kb-macro.wrap, when: kb-macro.active && statusBarFocused, args: {"command":"workbench.statusBar.focusPrevious"},
* left, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorLeft"},
* left, kb-macro.wrap, when: kb-macro.active && treestickyScrollFocused, args: {"command":"list.stickyScroll.collapse"},
* left, list.collapse, when: listFocus && treeElementCanCollapse && !inputFocus && !treestickyScrollFocused || listFocus && treeElementHasParent && !inputFocus && !treestickyScrollFocused,
* left, list.stickyScroll.collapse, when: treestickyScrollFocused,
* left, notebook.fold, when: notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook',
* left, notification.collapse, when: notificationFocus,
* left, previousCompressedFolder, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && !explorerViewletCompressedFirstFocus && !inputFocus,
* left, settings.action.focusTOC, when: inSettingsEditor && settingRowFocus,
* left, workbench.banner.focusPreviousAction, when: bannerFocused,
* left, workbench.statusBar.focusPrevious, when: statusBarFocused,
* m, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus && !notebookOutputFocused && activeEditor == 'workbench.editor.notebook' && notebookCellType == 'code', args: {"command":"notebook.cell.changeToMarkdown"},
* m, notebook.cell.changeToMarkdown, when: notebookEditorFocused && !inputFocus && !notebookOutputFocused && activeEditor == 'workbench.editor.notebook' && notebookCellType == 'code',
* pagedown, cursorPageDown, when: textInputFocus,
* pagedown, editor.action.pageDownHover, when: editorHoverFocused,
* pagedown, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.pageDownHover"},
* pagedown, kb-macro.wrap, when: editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused, args: {"command":"notebook.cell.cursorPageDown"},
* pagedown, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollDownPage"},
* pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* pagedown, kb-macro.wrap, when: interactivePlaygroundFocus && kb-macro.active && !editorTextFocus, args: {"command":"workbench.action.interactivePlayground.pageDown"},
* pagedown, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusPageDown"},
* pagedown, kb-macro.wrap, when: kb-macro.active && notificationFocus && notificationToastsVisible, args: {"command":"notifications.focusLastToast"},
* pagedown, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectNextPageSuggestion","record":"side-effect"},
* pagedown, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.selectNextPageSuggestion"},
* pagedown, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorPageDown"},
* pagedown, list.focusPageDown, when: listFocus && !inputFocus && !treestickyScrollFocused,
* pagedown, notebook.cell.cursorPageDown, when: editorTextFocus && inputFocus && notebookEditorFocused,
* pagedown, notifications.focusLastToast, when: notificationFocus && notificationToastsVisible,
* pagedown, quickInput.pageNext, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* pagedown, selectNextPageSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* pagedown, workbench.action.interactivePlayground.pageDown, when: interactivePlaygroundFocus && !editorTextFocus,
* pagedown, workbench.action.terminal.selectNextPageSuggestion, when: terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* pageup, cursorPageUp, when: textInputFocus,
* pageup, editor.action.pageUpHover, when: editorHoverFocused,
* pageup, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.pageUpHover"},
* pageup, kb-macro.wrap, when: editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused, args: {"command":"notebook.cell.cursorPageUp"},
* pageup, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollUpPage"},
* pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* pageup, kb-macro.wrap, when: interactivePlaygroundFocus && kb-macro.active && !editorTextFocus, args: {"command":"workbench.action.interactivePlayground.pageUp"},
* pageup, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusPageUp"},
* pageup, kb-macro.wrap, when: kb-macro.active && notificationFocus && notificationToastsVisible, args: {"command":"notifications.focusFirstToast"},
* pageup, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectPrevPageSuggestion","record":"side-effect"},
* pageup, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.selectPrevPageSuggestion"},
* pageup, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorPageUp"},
* pageup, list.focusPageUp, when: listFocus && !inputFocus && !treestickyScrollFocused,
* pageup, notebook.cell.cursorPageUp, when: editorTextFocus && inputFocus && notebookEditorFocused,
* pageup, notifications.focusFirstToast, when: notificationFocus && notificationToastsVisible,
* pageup, quickInput.pagePrevious, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* pageup, selectPrevPageSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* pageup, workbench.action.interactivePlayground.pageUp, when: interactivePlaygroundFocus && !editorTextFocus,
* pageup, workbench.action.terminal.selectPrevPageSuggestion, when: terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* right, breadcrumbs.focusNext, when: breadcrumbsActive && breadcrumbsVisible,
* right, cursorRight, when: textInputFocus,
* right, editor.action.scrollRightHover, when: editorHoverFocused,
* right, expandSectionCodeAction, when: codeActionMenuVisible && !codeActionMenuFilterFocused,
* right, iconSelectBox.focusNext, when: iconSelectBoxFocus && iconSelectBoxInputEmpty || iconSelectBoxFocus && !iconSelectBoxInputFocus,
* right, kb-macro.wrap, when: bannerFocused && kb-macro.active, args: {"command":"workbench.banner.focusNextAction"},
* right, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.focusNext"},
* right, kb-macro.wrap, when: codeActionMenuVisible && kb-macro.active && !codeActionMenuFilterFocused, args: {"command":"expandSectionCodeAction"},
* right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* right, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.scrollRightHover"},
* right, kb-macro.wrap, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerViewletCompressedLastFocus && !inputFocus, args: {"command":"nextCompressedFolder"},
* right, kb-macro.wrap, when: iconSelectBoxFocus && iconSelectBoxInputEmpty && kb-macro.active || iconSelectBoxFocus && kb-macro.active && !iconSelectBoxInputFocus, args: {"command":"iconSelectBox.focusNext"},
* right, kb-macro.wrap, when: kb-macro.active && listFocus && treeElementCanExpand && !inputFocus && !treestickyScrollFocused || kb-macro.active && listFocus && treeElementHasChild && !inputFocus && !treestickyScrollFocused, args: {"command":"list.expand"},
* right, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.unfold"},
* right, kb-macro.wrap, when: kb-macro.active && notificationFocus, args: {"command":"notification.expand"},
* right, kb-macro.wrap, when: kb-macro.active && statusBarFocused, args: {"command":"workbench.statusBar.focusNext"},
* right, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorRight"},
* right, list.expand, when: listFocus && treeElementCanExpand && !inputFocus && !treestickyScrollFocused || listFocus && treeElementHasChild && !inputFocus && !treestickyScrollFocused,
* right, nextCompressedFolder, when: explorerViewletCompressedFocus && filesExplorerFocus && foldersViewVisible && !explorerViewletCompressedLastFocus && !inputFocus,
* right, notebook.unfold, when: notebookEditorFocused && !inputFocus && activeEditor == 'workbench.editor.notebook',
* right, notification.expand, when: notificationFocus,
* right, quickInput.acceptInBackground, when: cursorAtEndOfQuickInputBox && inQuickInput && quickInputType == 'quickPick' || inQuickInput && !inputFocus && quickInputType == 'quickPick',
* right, workbench.banner.focusNextAction, when: bannerFocused,
* right, workbench.statusBar.focusNext, when: statusBarFocused,
* shift+alt+., editor.action.autoFix, when: textInputFocus && !editorReadonly && supportedCodeAction =~ /(\\s|^)quickfix\\b/,
* shift+alt+., kb-macro.wrap, when: kb-macro.active && textInputFocus && !editorReadonly && supportedCodeAction =~ /(\\s|^)quickfix\\b/, args: {"command":"editor.action.autoFix"},
* shift+alt+0, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.toggleEditorGroupLayout"},
* shift+alt+0, workbench.action.toggleEditorGroupLayout,
* shift+alt+1, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveEditorToFirstGroup"},
* shift+alt+1, workbench.action.moveEditorToFirstGroup,
* shift+alt+9, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.moveEditorToLastGroup"},
* shift+alt+9, workbench.action.moveEditorToLastGroup,
* shift+alt+a, editor.action.blockComment, when: editorTextFocus && !editorReadonly,
* shift+alt+a, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.blockComment"},
* shift+alt+c, copyFilePath, when: !editorFocus,
* shift+alt+c, copyFilePath, when: editorFocus,
* shift+alt+c, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"copyFilePath"},
* shift+alt+c, kb-macro.wrap, when: fileMatchOrFolderMatchWithResourceFocus && kb-macro.active, args: {"command":"search.action.copyPath"},
* shift+alt+c, kb-macro.wrap, when: kb-macro.active && !editorFocus, args: {"command":"copyFilePath"},
* shift+alt+c, search.action.copyPath, when: fileMatchOrFolderMatchWithResourceFocus,
* shift+alt+d, editor.detectLanguage, when: editorTextFocus && !notebookEditable,
* shift+alt+d, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !notebookEditable, args: {"command":"editor.detectLanguage"},
* shift+alt+d, kb-macro.wrap, when: kb-macro.active && notebookCellEditable && notebookEditable, args: {"command":"notebook.cell.detectLanguage"},
* shift+alt+d, notebook.cell.detectLanguage, when: notebookCellEditable && notebookEditable,
* shift+alt+down, editor.action.copyLinesDownAction, when: editorTextFocus && !editorReadonly,
* shift+alt+down, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.copyLinesDownAction"},
* shift+alt+down, kb-macro.wrap, when: false, args: {"command":"editor.action.insertCursorBelow"},
* shift+alt+down, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.copyDown"},
* shift+alt+down, notebook.cell.copyDown, when: notebookEditorFocused && !inputFocus,
* shift+alt+enter, kb-macro.wrap, when: chatInputHasText && inChatInput && kb-macro.active && !chatSessionRequestInProgress && chatAgentKind == 'ask', args: {"command":"workbench.action.chat.submitWithoutDispatching"},
* shift+alt+enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* shift+alt+enter, workbench.action.chat.submitWithoutDispatching, when: chatInputHasText && inChatInput && !chatSessionRequestInProgress && chatAgentKind == 'ask',
* shift+alt+f, editor.action.formatDocument, when: editorHasDocumentFormattingProvider && editorTextFocus && !editorReadonly && !inCompositeEditor,
* shift+alt+f, editor.action.formatDocument.none, when: editorTextFocus && !editorHasDocumentFormattingProvider && !editorReadonly,
* shift+alt+f, filesExplorer.findInFolder, when: explorerResourceIsFolder && filesExplorerFocus && foldersViewVisible && !inputFocus,
* shift+alt+f, kb-macro.wrap, when: editorHasDocumentFormattingProvider && editorTextFocus && inCompositeEditor && kb-macro.active && notebookEditable && !editorReadonly && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.formatCell"},
* shift+alt+f, kb-macro.wrap, when: editorHasDocumentFormattingProvider && editorTextFocus && kb-macro.active && !editorReadonly && !inCompositeEditor, args: {"command":"editor.action.formatDocument"},
* shift+alt+f, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorHasDocumentFormattingProvider && !editorReadonly, args: {"command":"editor.action.formatDocument.none"},
* shift+alt+f, kb-macro.wrap, when: explorerResourceIsFolder && filesExplorerFocus && foldersViewVisible && kb-macro.active && !inputFocus, args: {"command":"filesExplorer.findInFolder"},
* shift+alt+f, kb-macro.wrap, when: folderMatchWithResourceFocus && kb-macro.active && searchViewletVisible, args: {"command":"search.action.restrictSearchToFolder"},
* shift+alt+f, kb-macro.wrap, when: kb-macro.active && notebookEditable && !editorTextFocus && activeEditor == 'workbench.editor.notebook', args: {"command":"notebook.format"},
* shift+alt+f, notebook.format, when: notebookEditable && !editorTextFocus && activeEditor == 'workbench.editor.notebook',
* shift+alt+f, notebook.formatCell, when: editorHasDocumentFormattingProvider && editorTextFocus && inCompositeEditor && notebookEditable && !editorReadonly && activeEditor == 'workbench.editor.notebook',
* shift+alt+f, search.action.restrictSearchToFolder, when: folderMatchWithResourceFocus && searchViewletVisible,
* shift+alt+f1, editor.action.toggleScreenReaderAccessibilityMode,
* shift+alt+f1, kb-macro.wrap, when: false, args: {"command":"editor.action.accessibilityHelp"},
* shift+alt+f1, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.toggleScreenReaderAccessibilityMode"},
* shift+alt+f2, kb-macro.wrap, when: false, args: {"command":"editor.action.accessibleView"},
* shift+alt+f2, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.focusAccessibleBuffer"},
* shift+alt+f3, editor.action.dirtydiff.previous, when: editorTextFocus && !textCompareEditorActive,
* shift+alt+f3, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !textCompareEditorActive, args: {"command":"editor.action.dirtydiff.previous"},
* shift+alt+f3, kb-macro.wrap, when: kb-macro.active && activeEditor == 'workbench.editor.notebookTextDiffEditor', args: {"command":"notebook.diff.action.previous"},
* shift+alt+f3, notebook.diff.action.previous, when: activeEditor == 'workbench.editor.notebookTextDiffEditor',
* shift+alt+f4, kb-macro.wrap, when: false, args: {"command":"editor.action.toggleScreenReaderAccessibilityMode"},
* shift+alt+f5, chatEditor.action.navigatePrevious, when: chatEdits.hasEditorModifications && chatIsEnabled && editorFocus || chatEdits.hasEditorModifications && chatIsEnabled && notebookCellListFocused,
* shift+alt+f5, kb-macro.wrap, when: chatEdits.hasEditorModifications && chatIsEnabled && editorFocus && kb-macro.active || chatEdits.hasEditorModifications && chatIsEnabled && kb-macro.active && notebookCellListFocused, args: {"command":"chatEditor.action.navigatePrevious"},
* shift+alt+f5, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !textCompareEditorActive && quickDiffDecorationCount != '0', args: {"command":"workbench.action.editor.previousChange"},
* shift+alt+f5, kb-macro.wrap, when: kb-macro.active && activeEditor == 'multiDiffEditor', args: {"command":"multiDiffEditor.goToPreviousChange"},
* shift+alt+f5, kb-macro.wrap, when: kb-macro.active && textCompareEditorVisible, args: {"command":"workbench.action.compareEditor.previousChange"},
* shift+alt+f5, multiDiffEditor.goToPreviousChange, when: activeEditor == 'multiDiffEditor',
* shift+alt+f5, workbench.action.compareEditor.previousChange, when: textCompareEditorVisible,
* shift+alt+f5, workbench.action.editor.previousChange, when: editorTextFocus && !textCompareEditorActive && quickDiffDecorationCount != '0',
* shift+alt+f7, chatEditor.action.toggleDiff, when: chatEdits.hasEditorModifications && editorFocus,
* shift+alt+f7, kb-macro.wrap, when: chatEdits.hasEditorModifications && editorFocus && kb-macro.active, args: {"command":"chatEditor.action.toggleDiff"},
* shift+alt+f8, editor.action.marker.prev, when: editorFocus,
* shift+alt+f8, kb-macro.wrap, when: editorFocus && kb-macro.active && testing.isPeekVisible, args: {"command":"testing.goToPreviousMessage"},
* shift+alt+f8, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.marker.prev"},
* shift+alt+f8, testing.goToPreviousMessage, when: editorFocus && testing.isPeekVisible,
* shift+alt+f9, editor.action.previousCommentThreadAction,
* shift+alt+f9, kb-macro.wrap, when: activeEditor && kb-macro.active && testing.hasCoverageInFile, args: {"command":"testing.coverage.goToPreviousMissedLine"},
* shift+alt+f9, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.previousCommentThreadAction"},
* shift+alt+f9, testing.coverage.goToPreviousMissedLine, when: activeEditor && testing.hasCoverageInFile,
* shift+alt+f10, editor.action.previousCommentedRangeAction, when: activeEditorHasCommentingRange,
* shift+alt+f10, kb-macro.wrap, when: activeEditorHasCommentingRange && kb-macro.active, args: {"command":"editor.action.previousCommentedRangeAction"},
* shift+alt+f12, kb-macro.wrap, when: editorHasReferenceProvider && kb-macro.active, args: {"command":"references-view.findReferences"},
* shift+alt+f12, references-view.findReferences, when: editorHasReferenceProvider,
* shift+alt+h, editor.showCallHierarchy, when: editorHasCallHierarchyProvider && editorTextFocus && !inReferenceSearchEditor,
* shift+alt+h, editor.showIncomingCalls, when: callHierarchyVisible && callHierarchyDirection == 'outgoingCalls',
* shift+alt+h, editor.showOutgoingCalls, when: callHierarchyVisible && callHierarchyDirection == 'incomingCalls',
* shift+alt+h, editor.showSubtypes, when: typeHierarchyVisible && typeHierarchyDirection == 'supertypes',
* shift+alt+h, editor.showSupertypes, when: typeHierarchyVisible && typeHierarchyDirection == 'subtypes',
* shift+alt+h, kb-macro.wrap, when: callHierarchyVisible && kb-macro.active && callHierarchyDirection == 'incomingCalls', args: {"command":"editor.showOutgoingCalls"},
* shift+alt+h, kb-macro.wrap, when: callHierarchyVisible && kb-macro.active && callHierarchyDirection == 'outgoingCalls', args: {"command":"editor.showIncomingCalls"},
* shift+alt+h, kb-macro.wrap, when: editorHasCallHierarchyProvider && editorTextFocus && kb-macro.active && !inReferenceSearchEditor, args: {"command":"editor.showCallHierarchy"},
* shift+alt+h, kb-macro.wrap, when: editorHasCallHierarchyProvider && kb-macro.active, args: {"command":"references-view.showCallHierarchy"},
* shift+alt+h, kb-macro.wrap, when: kb-macro.active && typeHierarchyVisible && typeHierarchyDirection == 'subtypes', args: {"command":"editor.showSupertypes"},
* shift+alt+h, kb-macro.wrap, when: kb-macro.active && typeHierarchyVisible && typeHierarchyDirection == 'supertypes', args: {"command":"editor.showSubtypes"},
* shift+alt+h, references-view.showCallHierarchy, when: editorHasCallHierarchyProvider,
* shift+alt+i, editor.action.insertCursorAtEndOfEachLineSelected, when: editorTextFocus,
* shift+alt+i, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.insertCursorAtEndOfEachLineSelected"},
* shift+alt+left, editor.action.smartSelect.shrink, when: editorTextFocus,
* shift+alt+left, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.smartSelect.shrink"},
* shift+alt+left, kb-macro.wrap, when: false, args: {"command":"cursorWordLeftSelect"},
* shift+alt+o, editor.action.organizeImports, when: textInputFocus && !editorReadonly && supportedCodeAction =~ /(\\s|^)source\\.organizeImports\\b/,
* shift+alt+o, kb-macro.wrap, when: kb-macro.active && textInputFocus && !editorReadonly && supportedCodeAction =~ /(\\s|^)source\\.organizeImports\\b/, args: {"command":"editor.action.organizeImports"},
* shift+alt+oem_102, kb-macro.wrap, when: false, args: {"command":"editor.action.autoFix"},
* shift+alt+r, kb-macro.wrap, when: kb-macro.active && !editorFocus, args: {"command":"revealFileInOS"},
* shift+alt+r, remote-wsl.revealInExplorer, when: editorFocus && remoteName == 'wsl',
* shift+alt+r, revealFileInOS, when: !editorFocus,
* shift+alt+right, editor.action.smartSelect.expand, when: editorTextFocus,
* shift+alt+right, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.action.smartSelect.expand"},
* shift+alt+right, kb-macro.wrap, when: false, args: {"command":"cursorWordEndRightSelect"},
* shift+alt+up, editor.action.copyLinesUpAction, when: editorTextFocus && !editorReadonly,
* shift+alt+up, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly, args: {"command":"editor.action.copyLinesUpAction"},
* shift+alt+up, kb-macro.wrap, when: false, args: {"command":"editor.action.insertCursorAbove"},
* shift+alt+up, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.copyUp"},
* shift+alt+up, notebook.cell.copyUp, when: notebookEditorFocused && !inputFocus,
* shift+alt+win+c, kb-macro.wrap, when: kb-macro.active && !editorFocus, args: {"command":"copyRelativeFilePath"},
* shift+alt+win+down, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectDown"},
* shift+alt+win+j, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused, args: {"command":"notebook.cell.joinAbove"},
* shift+alt+win+j, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused, args: {"command":"notebook.cell.joinAbove"},
* shift+alt+win+j, notebook.cell.joinAbove, when: notebookEditorFocused,
* shift+alt+win+left, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectLeft"},
* shift+alt+win+pagedown, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectPageDown"},
* shift+alt+win+pageup, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectPageUp"},
* shift+alt+win+right, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectRight"},
* shift+alt+win+up, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectUp"},
* shift+backspace, deleteLeft, when: textInputFocus,
* shift+backspace, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"deleteLeft"},
* shift+delete, agentSession.unarchive, when: agentSessionIsArchived && agentSessionsViewerFocused,
* shift+delete, deleteFile, when: filesExplorerFocus && foldersViewVisible && !inputFocus,
* shift+delete, editor.action.clipboardCutAction,
* shift+delete, kb-macro.wrap, when: agentSessionIsArchived && agentSessionsViewerFocused && kb-macro.active, args: {"command":"agentSession.unarchive"},
* shift+delete, kb-macro.wrap, when: false, args: {"command":"editor.action.clipboardCutAction","await":"document clipboard"},
* shift+delete, kb-macro.wrap, when: false, args: {"command":"editor.action.clipboardCutAction","await":"document selection clipboard"},
* shift+delete, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !inputFocus, args: {"command":"deleteFile"},
* shift+delete, kb-macro.wrap, when: kb-macro.active && !kb-macro.headOfLine, args: {"command":"editor.action.clipboardCutAction","await":"document selection clipboard"},
* shift+delete, kb-macro.wrap, when: kb-macro.active && kb-macro.headOfLine, args: {"command":"editor.action.clipboardCutAction","await":"document clipboard"},
* shift+down, cursorColumnSelectDown, when: editorColumnSelection && textInputFocus,
* shift+down, cursorDownSelect, when: textInputFocus,
* shift+down, kb-macro.wrap, when: editorColumnSelection && kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectDown"},
* shift+down, kb-macro.wrap, when: kb-macro.active && listFocus && listSupportsMultiselect && !inputFocus && !treestickyScrollFocused, args: {"command":"list.expandSelectionDown"},
* shift+down, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorDownSelect"},
* shift+down, list.expandSelectionDown, when: listFocus && listSupportsMultiselect && !inputFocus && !treestickyScrollFocused,
* shift+end, cursorEndSelect, when: textInputFocus, args: {"sticky":false},
* shift+end, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollToBottom"},
* shift+end, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollToBottomAccessibleView"},
* shift+end, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorEndSelect","args":{"sticky":false}},
* shift+enter, acceptAlternativeSelectedSuggestion, when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* shift+enter, editor.action.extensioneditor.findPrevious, when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'workbench.editor.extension',
* shift+enter, editor.action.previousMatchFindAction, when: editorFocus && findInputFocussed,
* shift+enter, editor.action.webvieweditor.findPrevious, when: webviewFindWidgetFocused && !editorFocus && activeEditor == 'WebviewEditor',
* shift+enter, editor.refocusCallHierarchy, when: callHierarchyVisible,
* shift+enter, editor.refocusTypeHierarchy, when: typeHierarchyVisible,
* shift+enter, interactive.execute, when: config.interactiveWindow.executeWithShiftEnter && isCompositeNotebook && activeEditor == 'workbench.editor.interactive',
* shift+enter, kb-macro.wrap, when: browserFindWidgetFocused && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.findPrevious"},
* shift+enter, kb-macro.wrap, when: callHierarchyVisible && kb-macro.active, args: {"command":"editor.refocusCallHierarchy"},
* shift+enter, kb-macro.wrap, when: config.interactiveWindow.executeWithShiftEnter && isCompositeNotebook && kb-macro.active && !notebookCellListFocused && activeEditor == 'workbench.editor.repl', args: {"command":"repl.execute"},
* shift+enter, kb-macro.wrap, when: config.interactiveWindow.executeWithShiftEnter && isCompositeNotebook && kb-macro.active && activeEditor == 'workbench.editor.interactive', args: {"command":"interactive.execute"},
* shift+enter, kb-macro.wrap, when: config.terminal.integrated.enableWin32InputMode && kb-macro.active && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[24~c"}},
* shift+enter, kb-macro.wrap, when: editorFocus && findInputFocussed && kb-macro.active, args: {"command":"editor.action.previousMatchFindAction"},
* shift+enter, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && !inlineChatFocused && notebookCellType == 'markup' || kb-macro.active && notebookCellListFocused && notebookMissingKernelExtension && !inlineChatFocused && !notebookCellExecuting && notebookCellType == 'code' || kb-macro.active && notebookCellListFocused && !inlineChatFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || kb-macro.active && notebookCellListFocused && !inlineChatFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0, args: {"command":"notebook.cell.executeAndSelectBelow"},
* shift+enter, kb-macro.wrap, when: kb-macro.active && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus, args: {"command":"acceptAlternativeSelectedSuggestion","record":"side-effect"},
* shift+enter, kb-macro.wrap, when: kb-macro.active && terminalFindInputFocused && terminalHasBeenCreated || kb-macro.active && terminalFindInputFocused && terminalProcessSupported, args: {"command":"workbench.action.terminal.findNext"},
* shift+enter, kb-macro.wrap, when: kb-macro.active && typeHierarchyVisible, args: {"command":"editor.refocusTypeHierarchy"},
* shift+enter, kb-macro.wrap, when: kb-macro.active && webviewFindWidgetFocused && !editorFocus && activeEditor == 'WebviewEditor', args: {"command":"editor.action.webvieweditor.findPrevious"},
* shift+enter, kb-macro.wrap, when: kb-macro.active && webviewFindWidgetFocused && !editorFocus && activeEditor == 'workbench.editor.extension', args: {"command":"editor.action.extensioneditor.findPrevious"},
* shift+enter, notebook.cell.executeAndSelectBelow, when: notebookCellListFocused && !inlineChatFocused && notebookCellType == 'markup' || notebookCellListFocused && notebookMissingKernelExtension && !inlineChatFocused && !notebookCellExecuting && notebookCellType == 'code' || notebookCellListFocused && !inlineChatFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || notebookCellListFocused && !inlineChatFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0,
* shift+enter, quickInput.accept, when: inQuickInput && !isComposing && quickInputType != 'quickWidget',
* shift+enter, repl.execute, when: config.interactiveWindow.executeWithShiftEnter && isCompositeNotebook && !notebookCellListFocused && activeEditor == 'workbench.editor.repl',
* shift+enter, workbench.action.browser.findPrevious, when: browserFindWidgetFocused && activeEditor == 'workbench.editor.browser',
* shift+enter, workbench.action.terminal.findNext, when: terminalFindInputFocused && terminalHasBeenCreated || terminalFindInputFocused && terminalProcessSupported,
* shift+enter, workbench.action.terminal.sendSequence, when: config.terminal.integrated.enableWin32InputMode && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"text":"\u001b[24~c"},
* shift+escape, cancelLinkedEditingInput, when: LinkedEditingInputVisible && editorTextFocus,
* shift+escape, cancelRenameInput, when: editorFocus && renameInputVisible,
* shift+escape, cancelSelection, when: editorHasSelection && textInputFocus,
* shift+escape, closeBreakpointWidget, when: breakpointWidgetVisible && textInputFocus,
* shift+escape, closeFindWidget, when: editorFocus && findWidgetVisible && !isComposing,
* shift+escape, closeMarkersNavigation, when: editorFocus && markersNavigationVisible,
* shift+escape, closeParameterHints, when: editorFocus && parameterHintsVisible,
* shift+escape, closeQuickDiff, when: dirtyDiffVisible,
* shift+escape, closeReferenceSearch, when: editorTextFocus && referenceSearchVisible && !config.editor.stablePeek || referenceSearchVisible && !config.editor.stablePeek && !inputFocus,
* shift+escape, closeReferenceSearch, when: inReferenceSearchEditor && !config.editor.stablePeek,
* shift+escape, editor.action.inlineSuggest.hide, when: inInlineEditsPreviewEditor,
* shift+escape, hideCodeActionWidget, when: codeActionMenuVisible && kb-macro.active,
* shift+escape, hideCodeActionWidget, when: codeActionMenuVisible,
* shift+escape, hideSuggestWidget, when: suggestWidgetVisible && textInputFocus,
* shift+escape, kb-macro.wrap, when: LinkedEditingInputVisible && editorTextFocus && kb-macro.active, args: {"command":"cancelLinkedEditingInput"},
* shift+escape, kb-macro.wrap, when: breakpointWidgetVisible && kb-macro.active && textInputFocus, args: {"command":"closeBreakpointWidget"},
* shift+escape, kb-macro.wrap, when: commentEditorFocused && kb-macro.active || commentFocused && kb-macro.active, args: {"command":"workbench.action.hideComment"},
* shift+escape, kb-macro.wrap, when: dirtyDiffVisible && kb-macro.active, args: {"command":"closeQuickDiff"},
* shift+escape, kb-macro.wrap, when: editorFocus && findWidgetVisible && kb-macro.active && !isComposing, args: {"command":"closeFindWidget"},
* shift+escape, kb-macro.wrap, when: editorFocus && kb-macro.active && markersNavigationVisible, args: {"command":"closeMarkersNavigation"},
* shift+escape, kb-macro.wrap, when: editorFocus && kb-macro.active && parameterHintsVisible, args: {"command":"closeParameterHints"},
* shift+escape, kb-macro.wrap, when: editorFocus && kb-macro.active && renameInputVisible, args: {"command":"cancelRenameInput"},
* shift+escape, kb-macro.wrap, when: editorHasMultipleSelections && kb-macro.active && textInputFocus, args: {"command":"removeSecondaryCursors"},
* shift+escape, kb-macro.wrap, when: editorHasSelection && kb-macro.active && textInputFocus, args: {"command":"cancelSelection"},
* shift+escape, kb-macro.wrap, when: editorTextFocus && kb-macro.active && referenceSearchVisible && !config.editor.stablePeek || kb-macro.active && referenceSearchVisible && !config.editor.stablePeek && !inputFocus, args: {"command":"closeReferenceSearch"},
* shift+escape, kb-macro.wrap, when: inInlineEditsPreviewEditor && kb-macro.active, args: {"command":"editor.action.inlineSuggest.hide","record":"side-effect"},
* shift+escape, kb-macro.wrap, when: inQuickOpen && kb-macro.active, args: {"command":"workbench.action.closeQuickOpen"},
* shift+escape, kb-macro.wrap, when: inReferenceSearchEditor && kb-macro.active && !config.editor.stablePeek, args: {"command":"closeReferenceSearch"},
* shift+escape, kb-macro.wrap, when: inSnippetMode && kb-macro.active && textInputFocus, args: {"command":"leaveSnippet","record":"side-effect"},
* shift+escape, kb-macro.wrap, when: kb-macro.active && suggestWidgetVisible && textInputFocus, args: {"command":"hideSuggestWidget","record":"side-effect"},
* shift+escape, kb-macro.wrap, when: kb-macro.active && terminalFindVisible && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFindVisible && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.hideFind"},
* shift+escape, leaveSnippet, when: inSnippetMode && textInputFocus,
* shift+escape, removeSecondaryCursors, when: editorHasMultipleSelections && textInputFocus,
* shift+escape, workbench.action.closeQuickOpen, when: inQuickOpen,
* shift+escape, workbench.action.hideComment, when: commentEditorFocused || commentFocused,
* shift+escape, workbench.action.terminal.hideFind, when: terminalFindVisible && terminalFocusInAny && terminalHasBeenCreated || terminalFindVisible && terminalFocusInAny && terminalProcessSupported,
* shift+f3, editor.action.previousMatchFindAction, when: editorFocus,
* shift+f3, kb-macro.wrap, when: browserFindWidgetVisible && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.findPrevious"},
* shift+f3, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.previousMatchFindAction"},
* shift+f3, kb-macro.wrap, when: findWidgetVisible && kb-macro.active && notebookEditorFocused, args: {"command":"notebook.findPrevious.fromWidget"},
* shift+f3, kb-macro.wrap, when: kb-macro.active && terminalFindFocused && terminalHasBeenCreated || kb-macro.active && terminalFindFocused && terminalProcessSupported || kb-macro.active && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.findPrevious"},
* shift+f3, notebook.findPrevious.fromWidget, when: findWidgetVisible && notebookEditorFocused,
* shift+f3, workbench.action.browser.findPrevious, when: browserFindWidgetVisible && activeEditor == 'workbench.editor.browser',
* shift+f3, workbench.action.terminal.findPrevious, when: terminalFindFocused && terminalHasBeenCreated || terminalFindFocused && terminalProcessSupported || terminalFocusInAny && terminalHasBeenCreated || terminalFocusInAny && terminalProcessSupported,
* shift+f4, goToPreviousReference, when: inReferenceSearchEditor || referenceSearchVisible,
* shift+f4, kb-macro.wrap, when: hasSearchResult && kb-macro.active || inSearchEditor && kb-macro.active, args: {"command":"search.action.focusPreviousSearchResult"},
* shift+f4, kb-macro.wrap, when: inReferenceSearchEditor && kb-macro.active || kb-macro.active && referenceSearchVisible, args: {"command":"goToPreviousReference"},
* shift+f4, kb-macro.wrap, when: kb-macro.active && reference-list.hasResult && references-view.canNavigate, args: {"command":"references-view.prev"},
* shift+f4, references-view.prev, when: reference-list.hasResult && references-view.canNavigate,
* shift+f4, search.action.focusPreviousSearchResult, when: hasSearchResult || inSearchEditor,
* shift+f5, kb-macro.wrap, when: focusedSessionIsAttach && inDebugMode && kb-macro.active, args: {"command":"workbench.action.debug.disconnect"},
* shift+f5, kb-macro.wrap, when: inDebugMode && kb-macro.active && !focusedSessionIsAttach, args: {"command":"workbench.action.debug.stop"},
* shift+f5, workbench.action.debug.disconnect, when: focusedSessionIsAttach && inDebugMode,
* shift+f5, workbench.action.debug.stop, when: inDebugMode && !focusedSessionIsAttach,
* shift+f6, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.focusPreviousPart"},
* shift+f6, workbench.action.focusPreviousPart,
* shift+f7, editor.action.accessibleDiffViewer.prev, when: isInDiffEditor,
* shift+f7, editor.action.wordHighlight.prev, when: editorTextFocus && hasWordHighlights,
* shift+f7, kb-macro.wrap, when: editorTextFocus && hasWordHighlights && kb-macro.active, args: {"command":"editor.action.wordHighlight.prev"},
* shift+f7, kb-macro.wrap, when: isInDiffEditor && kb-macro.active, args: {"command":"editor.action.accessibleDiffViewer.prev"},
* shift+f8, editor.action.marker.prevInFiles, when: editorFocus,
* shift+f8, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.marker.prevInFiles"},
* shift+f9, editor.debug.action.toggleInlineBreakpoint, when: editorTextFocus,
* shift+f9, kb-macro.wrap, when: editorTextFocus && kb-macro.active, args: {"command":"editor.debug.action.toggleInlineBreakpoint"},
* shift+f9, kb-macro.wrap, when: inSettingsEditor && kb-macro.active, args: {"command":"settings.action.showContextMenu"},
* shift+f9, settings.action.showContextMenu, when: inSettingsEditor,
* shift+f10, editor.action.showContextMenu, when: textInputFocus,
* shift+f10, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"editor.action.showContextMenu"},
* shift+f11, kb-macro.wrap, when: kb-macro.active && debugState == 'stopped', args: {"command":"workbench.action.debug.stepOut"},
* shift+f11, workbench.action.debug.stepOut, when: debugState == 'stopped',
* shift+f12, editor.action.goToReferences, when: editorHasReferenceProvider && editorTextFocus && !inReferenceSearchEditor && !isInEmbeddedEditor,
* shift+f12, goToPreviousReference, when: inReferenceSearchEditor || referenceSearchVisible,
* shift+f12, kb-macro.wrap, when: editorHasReferenceProvider && editorTextFocus && kb-macro.active && !inReferenceSearchEditor && !isInEmbeddedEditor, args: {"command":"editor.action.goToReferences"},
* shift+f12, kb-macro.wrap, when: inReferenceSearchEditor && kb-macro.active || kb-macro.active && referenceSearchVisible, args: {"command":"goToPreviousReference"},
* shift+home, cursorHomeSelect, when: textInputFocus,
* shift+home, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollToTop"},
* shift+home, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.scrollToTopAccessibleView"},
* shift+home, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorHomeSelect"},
* shift+insert, editor.action.clipboardPasteAction,
* shift+insert, kb-macro.wrap, when: false, args: {"command":"workbench.action.terminal.pasteSelection"},
* shift+insert, kb-macro.wrap, when: kb-macro.active, args: {"command":"editor.action.clipboardPasteAction","await":"document selection"},
* shift+left, cursorColumnSelectLeft, when: editorColumnSelection && textInputFocus,
* shift+left, cursorLeftSelect, when: textInputFocus,
* shift+left, kb-macro.wrap, when: editorColumnSelection && kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectLeft"},
* shift+left, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorLeftSelect"},
* shift+pagedown, cursorColumnSelectPageDown, when: editorColumnSelection && textInputFocus,
* shift+pagedown, cursorPageDownSelect, when: textInputFocus,
* shift+pagedown, kb-macro.wrap, when: editorColumnSelection && kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectPageDown"},
* shift+pagedown, kb-macro.wrap, when: editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused && !notebookOutputFocused, args: {"command":"notebook.cell.cursorPageDownSelect"},
* shift+pagedown, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollDownPage"},
* shift+pagedown, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorPageDownSelect"},
* shift+pagedown, notebook.cell.cursorPageDownSelect, when: editorTextFocus && inputFocus && notebookEditorFocused && !notebookOutputFocused,
* shift+pagedown, workbench.action.terminal.scrollDownPage, when: terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
* shift+pageup, cursorColumnSelectPageUp, when: editorColumnSelection && textInputFocus,
* shift+pageup, cursorPageUpSelect, when: textInputFocus,
* shift+pageup, kb-macro.wrap, when: editorColumnSelection && kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectPageUp"},
* shift+pageup, kb-macro.wrap, when: editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused && !notebookOutputFocused, args: {"command":"notebook.cell.cursorPageUpSelect"},
* shift+pageup, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollUpPage"},
* shift+pageup, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorPageUpSelect"},
* shift+pageup, notebook.cell.cursorPageUpSelect, when: editorTextFocus && inputFocus && notebookEditorFocused && !notebookOutputFocused,
* shift+pageup, workbench.action.terminal.scrollUpPage, when: terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive,
* shift+right, cursorColumnSelectRight, when: editorColumnSelection && textInputFocus,
* shift+right, cursorRightSelect, when: textInputFocus,
* shift+right, kb-macro.wrap, when: editorColumnSelection && kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectRight"},
* shift+right, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorRightSelect"},
* shift+tab, acceptAlternativeSelectedSuggestion, when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* shift+tab, editor.action.inlineSuggest.commitAlternativeAction, when: inInlineEditsPreviewEditor,
* shift+tab, editor.action.inlineSuggest.commitAlternativeAction, when: inlineEditIsVisible && inlineSuggestionAlternativeActionVisible,
* shift+tab, insertPrevSuggestion, when: hasOtherSuggestions && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
* shift+tab, jumpToPrevSnippetPlaceholder, when: hasPrevTabstop && inSnippetMode && textInputFocus,
* shift+tab, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly && !editorTabMovesFocus, args: {"command":"outdent"},
* shift+tab, kb-macro.wrap, when: hasOtherSuggestions && kb-macro.active && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on', args: {"command":"insertPrevSuggestion","record":"side-effect"},
* shift+tab, kb-macro.wrap, when: hasPrevTabstop && inSnippetMode && kb-macro.active && textInputFocus, args: {"command":"jumpToPrevSnippetPlaceholder","record":"side-effect"},
* shift+tab, kb-macro.wrap, when: inInlineEditsPreviewEditor && kb-macro.active, args: {"command":"editor.action.inlineSuggest.commitAlternativeAction"},
* shift+tab, kb-macro.wrap, when: inlineEditIsVisible && inlineSuggestionAlternativeActionVisible && kb-macro.active, args: {"command":"editor.action.inlineSuggest.commitAlternativeAction"},
* shift+tab, kb-macro.wrap, when: kb-macro.active && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus, args: {"command":"acceptAlternativeSelectedSuggestion","record":"side-effect"},
* shift+tab, outdent, when: editorTextFocus && !editorReadonly && !editorTabMovesFocus,
* shift+up, cursorColumnSelectUp, when: editorColumnSelection && textInputFocus,
* shift+up, cursorUpSelect, when: textInputFocus,
* shift+up, kb-macro.wrap, when: editorColumnSelection && kb-macro.active && textInputFocus, args: {"command":"cursorColumnSelectUp"},
* shift+up, kb-macro.wrap, when: kb-macro.active && listFocus && listSupportsMultiselect && !inputFocus && !treestickyScrollFocused, args: {"command":"list.expandSelectionUp"},
* shift+up, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorUpSelect"},
* shift+up, list.expandSelectionUp, when: listFocus && listSupportsMultiselect && !inputFocus && !treestickyScrollFocused,
* shift+win+backspace, kb-macro.wrap, when: inSearchEditor && kb-macro.active, args: {"command":"search.searchEditor.action.deleteFileResults"},
* shift+win+g, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.previousMatchFindAction"},
* shift+win+g, kb-macro.wrap, when: findWidgetVisible && kb-macro.active && notebookEditorFocused, args: {"command":"notebook.findPrevious.fromWidget"},
* shift+win+g, kb-macro.wrap, when: kb-macro.active && terminalFindFocused && terminalHasBeenCreated || kb-macro.active && terminalFindFocused && terminalProcessSupported || kb-macro.active && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.findPrevious"},
* shift+win+i, kb-macro.wrap, when: config.chat.agent.enabled && kb-macro.active && !chatSetupDisabled && !chatSetupHidden, args: {"command":"workbench.action.chat.openagent"},
* shift+win+left, kb-macro.wrap, when: config.terminal.integrated.enableWin32InputMode && kb-macro.active && terminalFocus && terminalShellType == 'pwsh', args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[1;2H"}},
* shift+win+left, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorHomeSelect"},
* shift+win+right, kb-macro.wrap, when: config.terminal.integrated.enableWin32InputMode && kb-macro.active && terminalFocus && terminalShellIntegrationEnabled && !accessibilityModeEnabled && terminalShellType == 'pwsh', args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u001b[24~d"}},
* shift+win+right, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorEndSelect","args":{"sticky":false}},
* shift+win+u, kb-macro.wrap, when: kb-macro.active && workbench.panel.output.active, args: {"command":"workbench.action.output.toggleOutput"},
* shift+win+up, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.collapseAll"},
* space, breadcrumbs.revealFocused, when: breadcrumbsActive && breadcrumbsVisible,
* space, debug.toggleBreakpoint, when: breakpointsFocused && !inputFocus,
* space, filesExplorer.openFilePreserveFocus, when: filesExplorerFocus && foldersViewVisible && !explorerResourceIsFolder && !inputFocus,
* space, kb-macro.wrap, when: breadcrumbsActive && breadcrumbsVisible && kb-macro.active, args: {"command":"breadcrumbs.revealFocused"},
* space, kb-macro.wrap, when: breakpointsFocused && kb-macro.active && !inputFocus, args: {"command":"debug.toggleBreakpoint"},
* space, kb-macro.wrap, when: codeActionMenuVisible && kb-macro.active && !codeActionMenuFilterFocused, args: {"command":"toggleSectionCodeAction"},
* space, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceIsFolder && !inputFocus, args: {"command":"filesExplorer.openFilePreserveFocus"},
* space, kb-macro.wrap, when: inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickTree', args: {"command":"quickInput.toggleCheckbox"},
* space, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.toggleExpand"},
* space, kb-macro.wrap, when: kb-macro.active && listFocus && refactorPreview.enabled && !inputFocus && !treestickyScrollFocused, args: {"command":"refactorPreview.toggleCheckedState"},
* space, kb-macro.wrap, when: kb-macro.active && notificationFocus, args: {"command":"notification.toggle"},
* space, kb-macro.wrap, when: kb-macro.active && treestickyScrollFocused, args: {"command":"list.stickyScrolltoggleExpand"},
* space, list.stickyScrolltoggleExpand, when: treestickyScrollFocused,
* space, list.toggleExpand, when: listFocus && !inputFocus && !treestickyScrollFocused,
* space, notification.toggle, when: notificationFocus,
* space, quickInput.toggleCheckbox, when: inQuickInput && !inputFocus && quickInputType == 'quickPick' || inQuickInput && !inputFocus && quickInputType == 'quickTree',
* space, refactorPreview.toggleCheckedState, when: listFocus && refactorPreview.enabled && !inputFocus && !treestickyScrollFocused,
* space, toggleSectionCodeAction, when: codeActionMenuVisible && !codeActionMenuFilterFocused,
* tab, acceptSelectedSuggestion, when: suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus,
* tab, editor.action.inlineSuggest.commit, when: inInlineEditsPreviewEditor,
* tab, editor.action.inlineSuggest.commit, when: inlineEditIsVisible && tabShouldAcceptInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineEditIsVisible && inlineSuggestionVisible && tabShouldAcceptInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineSuggestionHasIndentationLessThanTabSize && inlineSuggestionVisible && !editor.hasSelection && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineEditIsVisible && inlineSuggestionHasIndentationLessThanTabSize && inlineSuggestionVisible && !editor.hasSelection && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible,
* tab, editor.action.inlineSuggest.jump, when: inlineEditIsVisible && tabShouldJumpToInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible,
* tab, editor.emmet.action.expandAbbreviation, when: config.emmet.triggerExpansionOnTab && editorTextFocus && !editorReadonly && !editorTabMovesFocus,
* tab, insertBestCompletion, when: atEndOfWord && textInputFocus && !hasOtherSuggestions && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
* tab, insertNextSuggestion, when: hasOtherSuggestions && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on',
* tab, insertSnippet, when: editorTextFocus && hasSnippetCompletions && !editorTabMovesFocus && !inSnippetMode,
* tab, jumpToNextSnippetPlaceholder, when: hasNextTabstop && inSnippetMode && textInputFocus,
* tab, kb-macro.wrap, when: atEndOfWord && kb-macro.active && textInputFocus && !hasOtherSuggestions && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on', args: {"command":"insertBestCompletion"},
* tab, kb-macro.wrap, when: config.emmet.triggerExpansionOnTab && editorTextFocus && kb-macro.active && !editorReadonly && !editorTabMovesFocus, args: {"command":"editor.emmet.action.expandAbbreviation"},
* tab, kb-macro.wrap, when: editorTextFocus && hasSnippetCompletions && kb-macro.active && !editorTabMovesFocus && !inSnippetMode, args: {"command":"insertSnippet","record":"side-effect"},
* tab, kb-macro.wrap, when: editorTextFocus && kb-macro.active && !editorReadonly && !editorTabMovesFocus, args: {"command":"tab"},
* tab, kb-macro.wrap, when: hasNextTabstop && inSnippetMode && kb-macro.active && textInputFocus, args: {"command":"jumpToNextSnippetPlaceholder","record":"side-effect"},
* tab, kb-macro.wrap, when: hasOtherSuggestions && kb-macro.active && textInputFocus && !inSnippetMode && !suggestWidgetVisible && config.editor.tabCompletion == 'on', args: {"command":"insertNextSuggestion","record":"side-effect"},
* tab, kb-macro.wrap, when: inInlineEditsPreviewEditor && kb-macro.active, args: {"command":"editor.action.inlineSuggest.commit","record":"side-effect"},
* tab, kb-macro.wrap, when: inlineEditIsVisible && kb-macro.active && tabShouldAcceptInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineEditIsVisible && inlineSuggestionVisible && kb-macro.active && tabShouldAcceptInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineSuggestionHasIndentationLessThanTabSize && inlineSuggestionVisible && kb-macro.active && !editor.hasSelection && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible || inlineEditIsVisible && inlineSuggestionHasIndentationLessThanTabSize && inlineSuggestionVisible && kb-macro.active && !editor.hasSelection && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible, args: {"command":"editor.action.inlineSuggest.commit","record":"side-effect"},
* tab, kb-macro.wrap, when: inlineEditIsVisible && kb-macro.active && tabShouldJumpToInlineEdit && !editorHoverFocused && !editorTabMovesFocus && !suggestWidgetVisible, args: {"command":"editor.action.inlineSuggest.jump"},
* tab, kb-macro.wrap, when: kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible, args: {"command":"workbench.action.terminal.acceptSelectedSuggestion"},
* tab, kb-macro.wrap, when: kb-macro.active && suggestWidgetHasFocusedSuggestion && suggestWidgetVisible && textInputFocus, args: {"command":"acceptSelectedSuggestion","record":"side-effect"},
* tab, tab, when: editorTextFocus && !editorReadonly && !editorTabMovesFocus,
* tab, workbench.action.terminal.acceptSelectedSuggestion, when: simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || simpleSuggestWidgetHasFocusedSuggestion && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible,
* up, cursorUp, when: textInputFocus,
* up, editor.action.scrollUpHover, when: editorHoverFocused,
* up, editor.action.selectPreviousStickyScrollLine, when: stickyScrollFocused,
* up, focusPreviousRenameSuggestion, when: renameInputVisible,
* up, history.showPrevious, when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && !isComposing && !suggestWidgetVisible,
* up, iconSelectBox.focusUp, when: iconSelectBoxFocus,
* up, interactive.history.previous, when: isCompositeNotebook && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none',
* up, kb-macro.wrap, when: bannerFocused && kb-macro.active, args: {"command":"workbench.banner.focusPreviousAction"},
* up, kb-macro.wrap, when: config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'both' && notebookEditorCursorAtBoundary != 'bottom' && notebookEditorCursorAtBoundary != 'none' || config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && kb-macro.active && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'start' && notebookEditorCursorAtBoundary != 'bottom' && notebookEditorCursorAtBoundary != 'none', args: {"command":"notebook.focusPreviousEditor"},
* up, kb-macro.wrap, when: config.notebook.navigation.allowNavigateToSurroundingCells && kb-macro.active && notebookCursorNavigationMode && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && !notebookCellMarkdownEditMode && notebookCellType == 'markup', args: {"command":"notebook.focusPreviousEditor"},
* up, kb-macro.wrap, when: config.terminal.integrated.suggest.upArrowNavigatesHistory && kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && !simpleSuggestWidgetHasNavigated || config.terminal.integrated.suggest.upArrowNavigatesHistory && kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && !simpleSuggestWidgetHasNavigated, args: {"command":"workbench.action.terminal.hideSuggestWidgetAndNavigateHistory"},
* up, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.scrollUpHover"},
* up, kb-macro.wrap, when: historyNavigationBackwardsEnabled && historyNavigationWidgetFocus && kb-macro.active && !isComposing && !suggestWidgetVisible, args: {"command":"history.showPrevious"},
* up, kb-macro.wrap, when: iconSelectBoxFocus && kb-macro.active, args: {"command":"iconSelectBox.focusUp"},
* up, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.previous"},
* up, kb-macro.wrap, when: interactivePlaygroundFocus && kb-macro.active && !editorTextFocus, args: {"command":"workbench.action.interactivePlayground.arrowUp"},
* up, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !notebookEditorFocused && !suggestWidgetVisible && interactiveInputCursorAtBoundary != 'bottom' && interactiveInputCursorAtBoundary != 'none', args: {"command":"interactive.history.previous"},
* up, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.focusUp"},
* up, kb-macro.wrap, when: kb-macro.active && notebookOutputInputFocused, args: {"command":"notebook.cell.nullAction"},
* up, kb-macro.wrap, when: kb-macro.active && notificationFocus && notificationToastsVisible, args: {"command":"notifications.focusPreviousToast"},
* up, kb-macro.wrap, when: kb-macro.active && renameInputVisible, args: {"command":"focusPreviousRenameSuggestion"},
* up, kb-macro.wrap, when: kb-macro.active && scmInputIsInFirstPosition && scmRepository && !suggestWidgetVisible, args: {"command":"scm.viewPreviousCommit"},
* up, kb-macro.wrap, when: kb-macro.active && simpleSuggestWidgetHasNavigated && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || kb-macro.active && simpleSuggestWidgetHasNavigated && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible || kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && !config.terminal.integrated.suggest.upArrowNavigatesHistory || kb-macro.active && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && !config.terminal.integrated.suggest.upArrowNavigatesHistory, args: {"command":"workbench.action.terminal.selectPrevSuggestion"},
* up, kb-macro.wrap, when: kb-macro.active && statusBarFocused, args: {"command":"workbench.statusBar.focusPrevious"},
* up, kb-macro.wrap, when: kb-macro.active && stickyScrollFocused, args: {"command":"editor.action.selectPreviousStickyScrollLine"},
* up, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectPrevSuggestion","record":"side-effect"},
* up, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorUp"},
* up, list.focusUp, when: listFocus && !inputFocus && !treestickyScrollFocused,
* up, notebook.cell.nullAction, when: notebookOutputInputFocused,
* up, notebook.focusPreviousEditor, when: config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'both' && notebookEditorCursorAtBoundary != 'bottom' && notebookEditorCursorAtBoundary != 'none' || config.notebook.navigation.allowNavigateToSurroundingCells && editorTextFocus && inputFocus && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && notebookEditorCursorAtLineBoundary == 'start' && notebookEditorCursorAtBoundary != 'bottom' && notebookEditorCursorAtBoundary != 'none',
* up, notebook.focusPreviousEditor, when: config.notebook.navigation.allowNavigateToSurroundingCells && notebookCursorNavigationMode && notebookEditorFocused && !accessibilityModeEnabled && !isEmbeddedDiffEditor && !notebookCellMarkdownEditMode && notebookCellType == 'markup',
* up, notifications.focusPreviousToast, when: notificationFocus && notificationToastsVisible,
* up, quickInput.previous, when: inQuickInput && quickInputType == 'quickPick' || inQuickInput && quickInputType == 'quickTree',
* up, scm.viewPreviousCommit, when: scmInputIsInFirstPosition && scmRepository && !suggestWidgetVisible,
* up, selectPrevCodeAction, when: codeActionMenuVisible && kb-macro.active,
* up, selectPrevCodeAction, when: codeActionMenuVisible,
* up, selectPrevSuggestion, when: suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion,
* up, showPrevParameterHint, when: editorFocus && kb-macro.active && parameterHintsMultipleSignatures && parameterHintsVisible,
* up, showPrevParameterHint, when: editorFocus && parameterHintsMultipleSignatures && parameterHintsVisible,
* up, workbench.action.interactivePlayground.arrowUp, when: interactivePlaygroundFocus && !editorTextFocus,
* up, workbench.action.terminal.hideSuggestWidgetAndNavigateHistory, when: config.terminal.integrated.suggest.upArrowNavigatesHistory && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && !simpleSuggestWidgetHasNavigated || config.terminal.integrated.suggest.upArrowNavigatesHistory && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && !simpleSuggestWidgetHasNavigated,
* up, workbench.action.terminal.selectPrevSuggestion, when: simpleSuggestWidgetHasNavigated && terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible || simpleSuggestWidgetHasNavigated && terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible || terminalFocus && terminalHasBeenCreated && terminalIsOpen && terminalSuggestWidgetVisible && !config.terminal.integrated.suggest.upArrowNavigatesHistory || terminalFocus && terminalIsOpen && terminalProcessSupported && terminalSuggestWidgetVisible && !config.terminal.integrated.suggest.upArrowNavigatesHistory,
* up, workbench.banner.focusPreviousAction, when: bannerFocused,
* up, workbench.statusBar.focusPrevious, when: statusBarFocused,
* win+-, kb-macro.wrap, when: browserFocused && browserHasUrl && kb-macro.active && !browserHasError && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.zoomOut"},
* win+-, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.zoomOut"},
* win+[, kb-macro.wrap, when: browserCanGoBack && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.goBack"},
* win+\\, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalProcessSupported || kb-macro.active && terminalFocus && terminalWebExtensionContributedProfile, args: {"command":"workbench.action.terminal.split"},
* win+\\, kb-macro.wrap, when: kb-macro.active && terminalProcessSupported && terminalTabsFocus, args: {"command":"workbench.action.terminal.splitActiveTab"},
* win+], kb-macro.wrap, when: browserCanGoForward && kb-macro.active && activeEditor == 'workbench.editor.browser', args: {"command":"workbench.action.browser.goForward"},
* win+a, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.selectAll"},
* win+backspace, kb-macro.wrap, when: explorerResourceMoveableToTrash && filesExplorerFocus && foldersViewVisible && kb-macro.active && !inputFocus, args: {"command":"moveFileToTrash"},
* win+backspace, kb-macro.wrap, when: hasUndecidedChatEditingResource && inChatInput && kb-macro.active && !chatInputHasText, args: {"command":"chatEditing.discardAllFiles"},
* win+backspace, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0015"}},
* win+backspace, kb-macro.wrap, when: kb-macro.active && terminalHasBeenCreated && terminalTabsFocus || kb-macro.active && terminalIsOpen && terminalTabsFocus || kb-macro.active && terminalProcessSupported && terminalTabsFocus, args: {"command":"workbench.action.terminal.killActiveTab"},
* win+backspace, kb-macro.wrap, when: kb-macro.active && textInputFocus && !editorReadonly, args: {"command":"deleteAllLeft"},
* win+backspace, kb-macro.wrap, when: kb-macro.active && tunnelCloseable && tunnelViewFocus, args: {"command":"remote.tunnel.closeInline"},
* win+c, kb-macro.wrap, when: kb-macro.active && terminalTextSelectedInFocused || kb-macro.active && terminalFocus && terminalHasBeenCreated && terminalTextSelected || kb-macro.active && terminalFocus && terminalProcessSupported && terminalTextSelected || kb-macro.active && terminalFocus && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalHasBeenCreated && terminalTextSelected && terminalTextSelectedInFocused || kb-macro.active && terminalProcessSupported && terminalTextSelected && terminalTextSelectedInFocused, args: {"command":"workbench.action.terminal.copySelection"},
* win+c, kb-macro.wrap, when: kb-macro.active, args: {"command":"execCopy"},
* win+delete, kb-macro.wrap, when: kb-macro.active && textInputFocus && !editorReadonly, args: {"command":"deleteAllRight"},
* win+down, kb-macro.wrap, when: commentsFilterFocus && kb-macro.active, args: {"command":"commentsFocusViewFromFilter"},
* win+down, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.goToBottomHover"},
* win+down, kb-macro.wrap, when: editorTextFocus && inlineChatVisible && kb-macro.active && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'above', args: {"command":"inlineChat.focus"},
* win+down, kb-macro.wrap, when: fileMatchOrMatchFocus && kb-macro.active && searchViewletVisible, args: {"command":"search.action.openResult"},
* win+down, kb-macro.wrap, when: filesExplorerFocus && foldersViewVisible && kb-macro.active && !explorerResourceIsFolder && !inputFocus, args: {"command":"explorer.openAndPassFocus"},
* win+down, kb-macro.wrap, when: inChat && inChatInput && kb-macro.active && quickChatHasFocus, args: {"command":"chat.action.focus"},
* win+down, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.nextSeparatorWithQuickAccessFallback"},
* win+down, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && notebookEditorFocused, args: {"command":"repl.input.focus"},
* win+down, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.select"},
* win+down, kb-macro.wrap, when: kb-macro.active && listFocus && referenceSearchVisible && !inputFocus && !treeElementCanCollapse && !treeElementCanExpand && !treestickyScrollFocused, args: {"command":"revealReference"},
* win+down, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.focusBottom"},
* win+down, kb-macro.wrap, when: kb-macro.active && problemFocus, args: {"command":"problems.action.open"},
* win+down, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectNextSuggestion","record":"side-effect"},
* win+down, kb-macro.wrap, when: kb-macro.active && treestickyScrollFocused, args: {"command":"list.stickyScrollselect"},
* win+e, kb-macro.wrap, when: kb-macro.active, args: {"command":"actions.findWithSelection"},
* win+end, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.scrollToBottomAccessibleView"},
* win+end, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollToBottom"},
* win+enter, kb-macro.wrap, when: editorFocus && findWidgetVisible && kb-macro.active && replaceInputFocussed, args: {"command":"editor.action.replaceAll"},
* win+enter, kb-macro.wrap, when: hasSearchResult && kb-macro.active && searchViewletFocus, args: {"command":"search.action.openInEditor"},
* win+enter, kb-macro.wrap, when: inQuickInput && kb-macro.active && !isComposing && quickInputType != 'quickWidget', args: {"command":"quickInput.accept"},
* win+enter, kb-macro.wrap, when: inputFocus && kb-macro.active && notebookEditorFocused && !inlineChatFocused && notebookCellType == 'markup', args: {"command":"notebook.cell.quitEdit"},
* win+enter, kb-macro.wrap, when: kb-macro.active && notebookCellListFocused && notebookMissingKernelExtension && !notebookCellExecuting && notebookCellType == 'code' || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelCount > 0 || kb-macro.active && notebookCellListFocused && !notebookCellExecuting && notebookCellType == 'code' && notebookKernelSourceCount > 0, args: {"command":"notebook.cell.execute"},
* win+escape, kb-macro.wrap, when: chatHasQuestionCarousel && kb-macro.active && !chatRemoteJobCreating || chatHasToolConfirmation && kb-macro.active && !chatRemoteJobCreating || chatSessionRequestInProgress && kb-macro.active && !chatRemoteJobCreating, args: {"command":"workbench.action.chat.cancel"},
* win+escape, kb-macro.wrap, when: commentWidgetVisible && editorFocus && kb-macro.active, args: {"command":"workbench.action.hideComment"},
* win+escape, kb-macro.wrap, when: inQuickInput && kb-macro.active, args: {"command":"quickInput.hide"},
* win+g, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"editor.action.nextMatchFindAction"},
* win+g, kb-macro.wrap, when: findWidgetVisible && kb-macro.active && notebookEditorFocused, args: {"command":"notebook.findNext.fromWidget"},
* win+g, kb-macro.wrap, when: kb-macro.active && terminalFindFocused && terminalHasBeenCreated || kb-macro.active && terminalFindFocused && terminalProcessSupported || kb-macro.active && terminalFocusInAny && terminalHasBeenCreated || kb-macro.active && terminalFocusInAny && terminalProcessSupported, args: {"command":"workbench.action.terminal.findNext"},
* win+home, kb-macro.wrap, when: accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.scrollToTopAccessibleView"},
* win+home, kb-macro.wrap, when: kb-macro.active && terminalFocusInAny && terminalHasBeenCreated && !terminalAltBufferActive || kb-macro.active && terminalFocusInAny && terminalProcessSupported && !terminalAltBufferActive, args: {"command":"workbench.action.terminal.scrollToTop"},
* win+i, kb-macro.wrap, when: config.notebook.experimental.cellChat && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus || config.notebook.experimental.generate && kb-macro.active && notebookChatAgentRegistered && notebookEditable && notebookEditorFocused && !inputFocus, args: {"command":"notebook.cell.chat.start"},
* win+k alt+win+c, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"copyFilePath"},
* win+k s, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.files.saveWithoutFormatting"},
* win+k shift+alt+win+c, kb-macro.wrap, when: editorFocus && kb-macro.active, args: {"command":"copyRelativeFilePath"},
* win+k win+k, kb-macro.wrap, when: kb-macro.active && resource == 'vscode-userdata:/Users/runner/work/vscode-kb-macro/vscode-kb-macro/empty2/User/keybindings.json', args: {"command":"editor.action.defineKeybinding"},
* win+k, kb-macro.wrap, when: kb-macro.active && focusedView == 'workbench.panel.repl.view', args: {"command":"workbench.debug.panel.action.clearReplAction"},
* win+k, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated && !accessibilityModeEnabled || kb-macro.active && terminalFocus && terminalProcessSupported && !accessibilityModeEnabled || accessibilityModeEnabled && accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibilityModeEnabled && accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.clear"},
* win+left, kb-macro.wrap, when: kb-macro.active && listFocus && !inputFocus && !treestickyScrollFocused, args: {"command":"list.collapseAll"},
* win+left, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0001"}},
* win+left, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorHome"},
* win+o, kb-macro.wrap, when: false, args: {"command":"workbench.action.files.openFile"},
* win+o, kb-macro.wrap, when: kb-macro.active && remoteFileDialogVisible, args: {"command":"workbench.action.files.openLocalFileFolder"},
* win+pagedown, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pageNext"},
* win+pageup, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.pagePrevious"},
* win+q, kb-macro.wrap, when: kb-macro.active, args: {"command":"workbench.action.quit"},
* win+r, kb-macro.wrap, when: accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalHasBeenCreated || accessibilityModeEnabled && kb-macro.active && terminalFocus && terminalProcessSupported || accessibilityModeEnabled && accessibleViewIsShown && kb-macro.active && terminalHasBeenCreated && accessibleViewCurrentProviderId == 'terminal' || accessibilityModeEnabled && accessibleViewIsShown && kb-macro.active && terminalProcessSupported && accessibleViewCurrentProviderId == 'terminal', args: {"command":"workbench.action.terminal.runRecentCommand"},
* win+r, kb-macro.wrap, when: chatIsEnabled && kb-macro.active && terminalChatFocus && terminalHasBeenCreated && !terminalChatActiveRequest || chatIsEnabled && kb-macro.active && terminalChatFocus && terminalProcessSupported && !terminalChatActiveRequest, args: {"command":"workbench.action.terminal.chat.rerunRequest"},
* win+r, kb-macro.wrap, when: false, args: {"command":"workbench.action.reloadWindow"},
* win+right, kb-macro.wrap, when: cursorAtEndOfQuickInputBox && inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && !inputFocus && quickInputType == 'quickPick', args: {"command":"quickInput.acceptInBackground"},
* win+right, kb-macro.wrap, when: kb-macro.active && terminalFocus, args: {"command":"workbench.action.terminal.sendSequence","args":{"text":"\u0005"}},
* win+right, kb-macro.wrap, when: kb-macro.active && textInputFocus, args: {"command":"cursorEnd","args":{"sticky":false}},
* win+up, kb-macro.wrap, when: chatCursorAtTop && inChatInput && kb-macro.active && !quickChatHasFocus, args: {"command":"chat.action.focus"},
* win+up, kb-macro.wrap, when: editorHoverFocused && kb-macro.active, args: {"command":"editor.action.goToTopHover"},
* win+up, kb-macro.wrap, when: editorTextFocus && inlineChatVisible && kb-macro.active && !accessibilityModeEnabled && !inlineChatFocused && !isEmbeddedDiffEditor && inlineChatOuterCursorPosition == 'below', args: {"command":"inlineChat.focus"},
* win+up, kb-macro.wrap, when: inChatInput && kb-macro.active && !quickChatHasFocus, args: {"command":"chat.action.focus"},
* win+up, kb-macro.wrap, when: inQuickInput && kb-macro.active && quickInputType == 'quickPick' || inQuickInput && kb-macro.active && quickInputType == 'quickTree', args: {"command":"quickInput.previousSeparatorWithQuickAccessFallback"},
* win+up, kb-macro.wrap, when: isCompositeNotebook && kb-macro.active && !notebookEditorFocused, args: {"command":"interactive.history.focus"},
* win+up, kb-macro.wrap, when: kb-macro.active && listFocus && treeElementCanCollapse && !inputFocus && !treestickyScrollFocused || kb-macro.active && listFocus && treeElementHasParent && !inputFocus && !treestickyScrollFocused, args: {"command":"list.collapse"},
* win+up, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus, args: {"command":"notebook.focusTop"},
* win+up, kb-macro.wrap, when: kb-macro.active && suggestWidgetMultipleSuggestions && suggestWidgetVisible && textInputFocus || kb-macro.active && suggestWidgetVisible && textInputFocus && !suggestWidgetHasFocusedSuggestion, args: {"command":"selectPrevSuggestion","record":"side-effect"},
* win+up, kb-macro.wrap, when: kb-macro.active && treestickyScrollFocused, args: {"command":"list.stickyScroll.collapse"},
* win+v, kb-macro.wrap, when: kb-macro.active && terminalFocus && terminalHasBeenCreated || kb-macro.active && terminalFocus && terminalProcessSupported, args: {"command":"workbench.action.terminal.paste"},
* win+v, kb-macro.wrap, when: kb-macro.active, args: {"command":"execPaste"},
* win+w, kb-macro.wrap, when: kb-macro.active && !editorIsOpen && !multipleEditorGroups, args: {"command":"workbench.action.closeWindow"},
* win+x, kb-macro.wrap, when: kb-macro.active, args: {"command":"execCut"},
* y, kb-macro.wrap, when: kb-macro.active && notebookEditorFocused && !inputFocus && !notebookOutputFocused && activeEditor == 'workbench.editor.notebook' && notebookCellType == 'markup', args: {"command":"notebook.cell.changeToCode"},
* y, notebook.cell.changeToCode, when: notebookEditorFocused && !inputFocus && !notebookOutputFocused && activeEditor == 'workbench.editor.notebook' && notebookCellType == 'markup'",

name:::
* McsEngl.VscCmd.Default Keyboard Shortcuts (palette),
* McsEngl.VscCmds.default,

ID of VscCmd (link)

VscCmd.SPECIFIC

description::
× HitpMcs-creation: {2026-04-04},

* menu-command,
* palette-command,
* shortcut-command,

name:::
* McsEngl.VscCmd.specific,

VscCmd.menu.file

description::
× HitpMcs-creation: {2026-03-26},
* New Text File Ctrl+N
* New File... Ctrl+Alt+Windows+N
* New Window Ctrl+Shift+N
* New Window with Profile
*
* Open File... Ctrl+O
* Open Folder... Ctrl+K Ctrl+O
* Open Workspace from File...
* Open Recent
*
* Add Folder to Workspace...
* Save Workspace As...
* Duplicate Workspace
*
* Save Ctrl+S
* Save As... Ctrl+Shift+S
* Save All Ctrl+K S
*
* Share
*
* Auto Save
* Preferences

"Here are the most useful **VS Code file commands**.
For **Windows/Linux**:
* `Ctrl+N` — New file
* `Ctrl+O` — Open file
* `Ctrl+S` — Save
* `Ctrl+Shift+S` — Save As
* `Ctrl+K S` — Save All
* `Ctrl+W` or `Ctrl+F4` — Close file
* `Ctrl+K Ctrl+W` — Close all files
* `Ctrl+Shift+T` — Reopen closed file/editor
* `Ctrl+P` — Quick Open file by name
* `Ctrl+K P` — Copy active file path
* `Ctrl+K R` — Reveal active file in Explorer
* `Ctrl+K O` — Open active file in new window
* `Ctrl+K Ctrl+O` — Open folder
* `Ctrl+Shift+E` — Focus Explorer
* `Ctrl+Alt+F` — Filter files/folders in Explorer
* `Ctrl+click` on a file path — Open linked file, or create it from a path in some contexts ([Visual Studio Code][1])
For **macOS**:
* `⌘N` — New file
* `⌘O` — Open file
* `⌘S` — Save
* `⇧⌘S` — Save As
* `⌥⌘S` — Save All
* `⌘W` — Close file
* `⌘K ⌘W` — Close all files
* `⇧⌘T` — Reopen closed file/editor
* `⌘P` — Quick Open file by name
* `⌘K P` — Copy active file path
* `⌘K R` — Reveal active file in Finder
* `⌘K O` — Open active file in new window
* `⇧⌘E` — Focus Explorer ([Visual Studio Code][2])
A few very handy **Command Palette** commands:
* `File: New File`
* `File: Open File`
* `File: Save`
* `File: Save All`
* `File: Revert File`
* `File: Copy Path of Active File`
* `File: Reveal Active File in Explorer`
* `File: Open Folder` ([Visual Studio Code][3])
You can also turn on **Auto Save** from `File > Auto Save`, so files save automatically without pressing save each time. ([Visual Studio Code][4])
If you want, I can also give you a **clean cheat sheet grouped by File / Explorer / Tabs / Folder commands**.
[1]: https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf?utm_source=chatgpt.com "keyboard-shortcuts-windows.pdf"
[2]: https://code.visualstudio.com/shortcuts/keyboard-shortcuts-macos.pdf?utm_source=chatgpt.com "Keyboard shortcuts for macOS"
[3]: https://code.visualstudio.com/docs/configure/keybindings?utm_source=chatgpt.com "Keyboard shortcuts for Visual Studio Code"
[4]: https://code.visualstudio.com/docs/editing/codebasics?utm_source=chatgpt.com "Basic editing""
[{2026-03-26 retrieved} https://chatgpt.com/c/69c44077-17b8-838d-8296-cbd75e904a26]

name:::
* McsEngl.VscCmd.file-menu,

File/New Text File: Ctrl+N::
* McsEngl.VscCmd.File/New Text File: Ctrl+N,
* McsEngl.VscCmd.New Text File: Ctrl+N//File,
* McsEngl.VscCmd.Ctrl+N: New Text File//File,
* McsEngl.VscCmds.Ctrl+N: New Text File//File,

File/New File...: Ctrl+Alt+Windows+N
* McsEngl.VscCmd.File/New File...: Ctrl+Alt+Windows+N,
* McsEngl.VscCmd.New File...: Ctrl+Alt+Windows+N//File,
* McsEngl.VscCmd.Ctrl+Alt+Windows+N: New File...//File,
* McsEngl.VscCmds.Ctrl+Alt+Windows+N: New File...//File,

File/New Window: Ctrl+Shift+N
* McsEngl.VscCmd.File/New Window: Ctrl+Shift+N,
* McsEngl.VscCmd.New Window: Ctrl+Shift+N//File,
* McsEngl.VscCmd.Ctrl+Shift+N: New Window//File,
* McsEngl.VscCmds.Ctrl+Shift+N: New Window//File,

File/Open File...: Ctrl+O
* McsEngl.VscCmd.File/Open File...: Ctrl+O,
* McsEngl.VscCmd.Open File...: Ctrl+O//File,
* McsEngl.VscCmd.Ctrl+O: Open File...//File,
* McsEngl.VscCmds.Ctrl+O: Open File...//File,

File/Open Folder...: Ctrl+K Ctrl+O
* McsEngl.VscCmd.File/Open Folder...: Ctrl+K Ctrl+O,
* McsEngl.VscCmd.Open Folder...: Ctrl+K Ctrl+O//File,
* McsEngl.VscCmd.Ctrl+K Ctrl+O: Open Folder...//File,
* McsEngl.VscCmds.Ctrl+K Ctrl+O: Open Folder...//File,

File/Save: Ctrl+S
* McsEngl.VscCmd.File/Save: Ctrl+S,
* McsEngl.VscCmd.Save: Ctrl+S//File,
* McsEngl.VscCmd.Ctrl+S: Save//File,
* McsEngl.VscCmds.Ctrl+S: Save//File,

File/Save As...: Ctrl+Shift+S
* McsEngl.VscCmd.File/Save As...: Ctrl+Shift+S,
* McsEngl.VscCmd.Save As...: Ctrl+Shift+S//File,
* McsEngl.VscCmd.Ctrl+Shift+S: Save As...//File,
* McsEngl.VscCmds.Ctrl+Shift+S: Save As...//File,

File/Save All: Ctrl+K S
* McsEngl.VscCmd.File/Save All: Ctrl+K S,
* McsEngl.VscCmd.Save All: Ctrl+K S//File,
* McsEngl.VscCmd.Ctrl+K S: Save All//File,
* McsEngl.VscCmds.Ctrl+K S: Save All//File,

File/Open Workspace from File...
* McsEngl.VscCmd.File/Open Workspace from File...,
* McsEngl.VscCmd.Open Workspace from File...//File,

File/Open Recent
* McsEngl.VscCmd.File/Open Recent,
* McsEngl.VscCmd.Open Recent//File,

File/Add Folder to Workspace...
* McsEngl.VscCmd.File/Add Folder to Workspace...,
* McsEngl.VscCmd.Add Folder to Workspace...//File,

File/Save Workspace As...
* McsEngl.VscCmd.File/Save Workspace As...,
* McsEngl.VscCmd.Save Workspace As...//File,

File/Duplicate Workspace
* McsEngl.VscCmd.File/Duplicate Workspace,
* McsEngl.VscCmd.Duplicate Workspace//File,

File/Share
* McsEngl.VscCmd.File/Share,
* McsEngl.VscCmd.Share//File,

File/Auto Save
· By default, VS Code doesn't automatically save modified files. Select a value from the Auto Save dropdown to change this behavior.
* McsEngl.VscCmd.File/Auto Save,
* McsEngl.VscCmd.Auto Save//File,

File/Revert File
* McsEngl.VscCmd.File/Revert File,
* McsEngl.VscCmd.Revert File//File,

File/Close Editor
* McsEngl.VscCmd.File/Close Editor,
* McsEngl.VscCmd.Close Editor//File,

File/Close Folder
* McsEngl.VscCmd.File/Close Folder,
* McsEngl.VscCmd.Close Folder//File,

File/Close Window
* McsEngl.VscCmd.File/Close Window,
* McsEngl.VscCmd.Close Window//File,

File/Exit
* McsEngl.VscCmd.File/Exit,
* McsEngl.VscCmd.Exit//File,

File/New Window with Profile
* McsEngl.VscCmd.File/New Window with Profile,
* McsEngl.VscCmd.New Window with Profile//File,

VscCmd.preferences//file

description::
× HitpMcs-creation: {2026-03-27},
* Profiles
*
* Settings: Ctrl+,
* Extensions: Ctrl+Shift+X
* Keyboard Shortcuts: Ctrl+K Ctrl+S
* Configure Snippets
* Tasks
* Themes
*
* Backup and Sync Settings...
*
* Online Services Settings

name:::
* McsEngl.VscCmd.File/Preferences,
* McsEngl.VscCmd.Preferences//File,
* McsEngl.Vscode'preferences//File,

File/Preferences/Profiles
* McsEngl.VscCmd.File/Preferences/Profiles,
* McsEngl.VscCmd.Profiles//Preferences//File,
* McsEngl.Vscode'Profiles//Preferences//File,

File/Preferences/Settings: Ctrl+,

File/Preferences/Extensions: Ctrl+Shift+X (link)

File/Preferences/Keyboard Shortcuts: Ctrl+K Ctrl+S

File/Preferences/Themes
· Themes let you modify VS Code's appearance to match your preferences. VS Code comes with several built-in themes. You can install more themes from the Visual Studio Marketplace.
Color themes enable you to modify the colors in the Visual Studio Code user interface to match your preferences and work environment. A theme affects both the VS Code user interface elements and the editor highlighting colors. VS Code supports both light and dark color themes to suit different lighting environments and personal preferences.
* McsEngl.VscCmd.File/Preferences/Themes,
* McsEngl.VscCmd.Themes//Preferences//File,
* McsEngl.Vscode'themes,

File/Preferences/Backup and Sync Settings...
* McsEngl.VscCmd.File/Preferences/Backup and Sync Settings...,
* McsEngl.VscCmd.Backup and Sync Settings...//Preferences//File,

File/Preferences/Online Services Settings
* McsEngl.VscCmd.File/Preferences/Online Services Settings,
* McsEngl.VscCmd.Online Services Settings//Preferences//File,

VscCmd.tasks//preferences//file

description::
× HitpMcs-creation: {2026-03-28},
× %APPDATA%\Code\User\tasks.json
· https://code.visualstudio.com/docs/debugtest/tasks

· Tasks in VS Code can be configured to run scripts and start processes so that many of existing tools [like linting, building, packaging, mostly run from the command line] can be used from within VS Code without having to enter a command line or write new code. Workspace or folder specific tasks are configured from the tasks.json file in the .vscode folder for a workspace.

name:::
* McsEngl.VscCmd.File/Preferences/Tasks,
* McsEngl.VscCmd.Tasks//Preferences//File,
* McsEngl.Vscode'tasks.json,

VscCmd.Snippets//preferences//file

description::
× HitpMcs-creation: {2026-03-28},
"VS Code snippets are templates that make it easier to enter repeating code patterns, such as loops or conditional-statements. They can be triggered by typing a "prefix" and pressing `Tab`, or through the **IntelliSense** menu.
---
## 1. Types of Snippets
VS Code categorizes snippets based on their "scope" (where they are available):
* **Language-Specific:** Only appear when you are editing a specific file type (e.g., `.js`, `.py`).
* **Global Snippets:** Available across all file types. These files use the `.code-snippets` extension.
* **Project-Specific:** Saved in a `.vscode` folder at the root of your workspace. These are perfect for sharing specific team patterns via Git.
* **Extension Snippets:** Many extensions (like "ES7+ React/Redux/React-Native snippets") bundle their own snippets into the editor.
---
## 2. Anatomy of a Snippet
Snippets are defined in **JSON** files. Here is a breakdown of the standard structure:
json
"Print to console": {
"prefix": "log",
"body": [
"console.log('${1:message}');",
"$0"
],
"description": "Log output to console"
}

### Key Components:
* **Prefix:** The text you type to trigger the snippet (e.g., typing `log`).
* **Body:** The actual code to insert. It can be a single string or an array of strings (each element is a new line).
* **Description:** Hover text shown in the IntelliSense menu.
* **Tab Stops (`$1`, `$2`):** Defines where the cursor moves when you press `Tab`.
* **Placeholders (`${1:default}`):** Tab stops with default text that is highlighted for easy replacement.
* **Final Cursor Position (`$0`):** Where the cursor ends up after you finish tabbing through the snippet.
---
## 3. Dynamic Snippets (Variables)
You can use built-in variables to make snippets "smarter."
| Variable | Description |
| `TM_FILENAME` | The name of the current file. |
| `TM_DIRECTORY` | The path to the current directory. |
| `CURRENT_YEAR` | The current year (e.g., 2026). |
| `CLIPBOARD` | The contents of your clipboard. |
| `TM_SELECTED_TEXT` | The text you had selected before triggering the snippet. |
---
## 4. How to Manage Snippets
To create or edit your own, follow these steps:
1. Open the **Command Palette** (`Ctrl+Shift+P` or `Cmd+Shift+P`).
2. Type **"Snippets: Configure User Snippets"**.
3. Select a language (e.g., `python`) or choose **"New Global Snippets file"**.
4. Add your JSON definition inside the curly braces of the file that opens.
---
## 5. Pro Tips
* **Choice Menus:** You can provide a list of options using `${1|choice1,choice2,choice3|}`.
* **Transformation:** You can use RegEx to transform variables (e.g., turning a filename into a ClassName by capitalizing the first letter).
* **Tab Completion:** If snippets aren't appearing when you hit Tab, ensure `"editor.tabCompletion": "on"` is set in your `settings.json`.
**Would you like me to help you write a specific custom snippet for a language you're currently using?**"
[{2026-03-28 retrieved} https://gemini.google.com/app/b70993dde329cb00]

name:::
* McsEngl.VscCmd.File/Preferences/Configure Snippets!⇒VscSnpt,
* McsEngl.VscCmd.Configure Snippets//Preferences//File!⇒VscSnpt,
* McsEngl.VscSnpt!=Vscode'snippets,
* McsEngl.Vscode'snippets!⇒VscSnpt,

CommandId of VscSnpt

description::
× HitpMcs-creation: {2026-03-31},
× CommandId: editor.action.insertSnippet,
·

name:::
* McsEngl.VscCmd.editor.action.insertSnippet,
* McsEngl.VscCmdi.editor.action.insertSnippet,
* McsEngl.VscSnpt'CommandId,
* McsEngl.VscSnpt'Id,

variable of VscSnpt

description::
× HitpMcs-creation: {2026-03-31},
* `CLIPBOARD` | The contents of your clipboard. |
* `CURRENT_DATE` | The current DATE (e.g., 26). |
* `CURRENT_MONTH` | The current month (e.g., 02). |
* `CURRENT_YEAR` | The current year (e.g., 2026). |
* `TM_DIRECTORY` | The path to the current directory. |
* `TM_FILENAME` | The name of the current file. |
* `TM_SELECTED_TEXT` | The text you had selected before triggering the snippet. |

name:::
* McsEngl.VscSnpt'variable,

VscCmd.menu.edit

description::
× HitpMcs-creation: {2026-03-26},
* Undo Ctrl+Z
* Redo Ctrl+Y
*
* Cut Ctrl+X
* Copy Ctrl+C
* Paste Ctrl+V
*
* Find Ctrl+F
* Replace Ctrl+H
*
* Find in Files Ctrl+Shift+F
* Replace in Files Ctrl+Shift+H
*
* Toggle Line Comment Ctrl+/
* Toggle Block Comment Shift+Alt+A
* Emmet: Expand Abbreviation Tab

name:::
* McsEngl.VscCmd.edit-menu,

Edit/Undo: Ctrl+Z
* McsEngl.VscCmd.Edit/Undo: Ctrl+Z,
* McsEngl.VscCmd.Undo: Ctrl+Z//Edit,
* McsEngl.VscCmd.Ctrl+Z: Undo//Edit,
* McsEngl.VscCmds.Ctrl+Z: Undo//Edit,

Edit/Redo: Ctrl+Y
* McsEngl.VscCmd.Edit/Redo: Ctrl+Y,
* McsEngl.VscCmd.Redo: Ctrl+Y//Edit,
* McsEngl.VscCmd.Ctrl+Y: Redo//Edit,
* McsEngl.VscCmds.Ctrl+Y: Redo//Edit,

Edit/Cut: Ctrl+X
* McsEngl.VscCmd.Edit/Cut: Ctrl+X,
* McsEngl.VscCmd.Cut: Ctrl+X//Edit,
* McsEngl.VscCmd.Ctrl+X: Cut//Edit,
* McsEngl.VscCmds.Ctrl+X: Cut//Edit,

Edit/Copy: Ctrl+C
* McsEngl.VscCmd.Edit/Copy: Ctrl+C,
* McsEngl.VscCmd.Copy: Ctrl+C//Edit,
* McsEngl.VscCmd.Ctrl+C: Copy//Edit,
* McsEngl.VscCmds.Ctrl+C: Copy//Edit,

Edit/Paste: Ctrl+V
* McsEngl.VscCmd.Edit/Paste: Ctrl+V,
* McsEngl.VscCmd.Paste: Ctrl+V//Edit,
* McsEngl.VscCmd.Ctrl+V: Paste//Edit,
* McsEngl.VscCmds.Ctrl+V: Paste//Edit,

Edit/Find: Ctrl+F
"No. actions.find is the plain “open in-editor Find” command, and the current VS Code built-in commands reference does not list any arguments for it. Recent VS Code issues also confirm that passing args to actions.find does not work.
If you want arguments, use editor.actions.findWithArgs instead. VS Code documents these supported fields: searchString, replaceString, isRegex, preserveCase, findInSelection, matchWholeWord, and isCaseSensitive." [ChatGpt]

* McsEngl.VscCmd.actions.find,
* McsEngl.VscCmd.actions.findWithArgs,
* McsEngl.VscCmd.Edit/Find: Ctrl+F,
* McsEngl.VscCmd.Find: Ctrl+F//Edit,
* McsEngl.VscCmd.Ctrl+F: Find//Edit,
* McsEngl.VscCmdi.actions.find,
* McsEngl.VscCmdi.actions.findWithArgs,
* McsEngl.VscCmds.Ctrl+F: Find//Edit,

Edit/Replace: Ctrl+H
* McsEngl.VscCmd.Edit/Replace: Ctrl+H,
* McsEngl.VscCmd.Replace: Ctrl+H//Edit,
* McsEngl.VscCmd.Ctrl+H: Replace//Edit,
* McsEngl.VscCmds.Ctrl+H: Replace//Edit,

Edit/Find in Files: Ctrl+Shift+F
* McsEngl.VscCmd.Edit/Find in Files: Ctrl+Shift+F,
* McsEngl.VscCmd.Find in Files: Ctrl+Shift+F//Edit,
* McsEngl.VscCmd.Ctrl+Shift+F: Find in Files//Edit,
* McsEngl.VscCmds.Ctrl+Shift+F: Find in Files//Edit,

Edit/Replace in Files: Ctrl+Shift+H
* McsEngl.VscCmd.Edit/Replace in Files: Ctrl+Shift+H,
* McsEngl.VscCmd.Replace in Files: Ctrl+Shift+H//Edit,
* McsEngl.VscCmd.Ctrl+Shift+H: Replace in Files//Edit,
* McsEngl.VscCmds.Ctrl+Shift+H: Replace in Files//Edit,

Edit/Toggle Line Comment: Ctrl+/
* McsEngl.VscCmd.Edit/Toggle Line Comment: Ctrl+/,
* McsEngl.VscCmd.Toggle Line Comment: Ctrl+///Edit,
* McsEngl.VscCmd.Ctrl+/: Toggle Line Comment//Edit,
* McsEngl.VscCmds.Ctrl+/: Toggle Line Comment//Edit,

Edit/Toggle Block Comment: Shift+Alt+A
* McsEngl.VscCmd.Edit/Toggle Block Comment: Shift+Alt+A,
* McsEngl.VscCmd.Toggle Block Comment: Shift+Alt+A//Edit,
* McsEngl.VscCmd.Shift+Alt+A: Toggle Block Comment//Edit,
* McsEngl.VscCmds.Shift+Alt+A: Toggle Block Comment//Edit,

Edit/Emmet: Expand Abbreviation: Tab
* McsEngl.VscCmd.Edit/Emmet: Expand Abbreviation: Tab,
* McsEngl.VscCmd.Emmet: Expand Abbreviation: Tab//Edit,
* McsEngl.VscCmd.Tab: Emmet: Expand Abbreviation//Edit,
* McsEngl.VscCmds.Tab: Emmet: Expand Abbreviation//Edit,

VscCmd.menu.selection

description::
× HitpMcs-creation: {2026-03-26},
* Select All Ctrl+A
* Expand Selection Shift+Alt+RightArrow
* Shrink Selection Shift+Alt+LeftArrow
*
* Copy Line Up Shift+Alt+UpArrow
* Copy Line Down Shift+Alt+DownArrow
* Move Line Up Alt+UpArrow
* Move Line Down Alt+DownArrow
* Duplicate Selection
*
* Add Cursor Above Ctrl+Alt+UpArrow
* Add Cursor Below Ctrl+Alt+DownArrow
* Add Cursors to Line Ends Shift+Alt+I
* Add Next Occurrence Ctrl+D
* Add Previous Occurrence
* Select All Occurrences Ctrl+Shift+L
*
* Switch to Ctrl+Click for Multi-Cursor
* Column Selection Mode

name:::
* McsEngl.VscCmd.selection-menu,

Selection/Select All: Ctrl+A
* McsEngl.VscCmd.Selection/Select All: Ctrl+A,
* McsEngl.VscCmd.Select All: Ctrl+A//Selection,
* McsEngl.VscCmd.Ctrl+A: Select All//Selection,
* McsEngl.VscCmds.Ctrl+A: Select All//Selection,

Selection/Expand Selection: Shift+Alt+RightArrow
* McsEngl.VscCmd.Selection/Expand Selection: Shift+Alt+RightArrow,
* McsEngl.VscCmd.Expand Selection: Shift+Alt+RightArrow//Selection,
* McsEngl.VscCmd.Shift+Alt+RightArrow: Expand Selection//Selection,
* McsEngl.VscCmds.Shift+Alt+RightArrow: Expand Selection//Selection,

Selection/Shrink Selection: Shift+Alt+LeftArrow
* McsEngl.VscCmd.Selection/Shrink Selection: Shift+Alt+LeftArrow,
* McsEngl.VscCmd.Shrink Selection: Shift+Alt+LeftArrow//Selection,
* McsEngl.VscCmd.Shift+Alt+LeftArrow: Shrink Selection//Selection,
* McsEngl.VscCmds.Shift+Alt+LeftArrow: Shrink Selection//Selection,

Selection/Copy Line Up: Shift+Alt+UpArrow
* McsEngl.VscCmd.Duplicate Line Up: Shift+Alt+UpArrow,
* McsEngl.VscCmd.Selection/Copy Line Up: Shift+Alt+UpArrow,
* McsEngl.VscCmd.Copy Line Up: Shift+Alt+UpArrow//Selection,
* McsEngl.VscCmd.Shift+Alt+UpArrow: Copy Line Up//Selection,
* McsEngl.VscCmds.Shift+Alt+UpArrow: Copy Line Up//Selection,

Selection/Copy Line Down: Shift+Alt+DownArrow
* McsEngl.VscCmd.Duplicate Line Down: Shift+Alt+DownArrow,
* McsEngl.VscCmd.Selection/Copy Line Down: Shift+Alt+DownArrow,
* McsEngl.VscCmd.Copy Line Down: Shift+Alt+DownArrow//Selection,
* McsEngl.VscCmd.Shift+Alt+DownArrow: Copy Line Down//Selection,
* McsEngl.VscCmds.Shift+Alt+DownArrow: Copy Line Down//Selection,

Selection/Move Line Up: Alt+UpArrow
* McsEngl.VscCmd.Selection/Move Line Up: Alt+UpArrow,
* McsEngl.VscCmd.Move Line Up: Alt+UpArrow//Selection,
* McsEngl.VscCmd.Alt+UpArrow: Move Line Up//Selection,
* McsEngl.VscCmds.Alt+UpArrow: Move Line Up//Selection,

Selection/Move Line Down: Alt+DownArrow
* McsEngl.VscCmd.Selection/Move Line Down: Alt+DownArrow,
* McsEngl.VscCmd.Move Line Down: Alt+DownArrow//Selection,
* McsEngl.VscCmd.Alt+DownArrow: Move Line Down//Selection,
* McsEngl.VscCmds.Alt+DownArrow: Move Line Down//Selection,

Selection/Add Cursor Above: Ctrl+Alt+UpArrow
* McsEngl.VscCmd.Selection/Add Cursor Above: Ctrl+Alt+UpArrow,
* McsEngl.VscCmd.Add Cursor Above: Ctrl+Alt+UpArrow//Selection,
* McsEngl.VscCmd.Ctrl+Alt+UpArrow: Add Cursor Above//Selection,
* McsEngl.VscCmds.Ctrl+Alt+UpArrow: Add Cursor Above//Selection,

Selection/Add Cursor Below: Ctrl+Alt+DownArrow
* McsEngl.VscCmd.Selection/Add Cursor Below: Ctrl+Alt+DownArrow,
* McsEngl.VscCmd.Add Cursor Below: Ctrl+Alt+DownArrow//Selection,
* McsEngl.VscCmd.Ctrl+Alt+DownArrow: Add Cursor Below//Selection,
* McsEngl.VscCmds.Ctrl+Alt+DownArrow: Add Cursor Below//Selection,

Selection/Add Cursors to Line Ends: Shift+Alt+I
* McsEngl.VscCmd.Selection/Add Cursors to Line Ends: Shift+Alt+I,
* McsEngl.VscCmd.Add Cursors to Line Ends: Shift+Alt+I//Selection,
* McsEngl.VscCmd.Shift+Alt+I: Add Cursors to Line Ends//Selection,
* McsEngl.VscCmds.Shift+Alt+I: Add Cursors to Line Ends//Selection,

Selection/Add Next Occurrence: Ctrl+D
* McsEngl.VscCmd.Selection/Add Next Occurrence: Ctrl+D,
* McsEngl.VscCmd.Add Next Occurrence: Ctrl+D//Selection,
* McsEngl.VscCmd.Ctrl+D: Add Next Occurrence//Selection,
* McsEngl.VscCmds.Ctrl+D: Add Next Occurrence//Selection,

Selection/Select All Occurrences: Ctrl+Shift+L
* McsEngl.VscCmd.Selection/Select All Occurrences: Ctrl+Shift+L,
* McsEngl.VscCmd.Select All Occurrences: Ctrl+Shift+L//Selection,
* McsEngl.VscCmd.Ctrl+Shift+L: Select All Occurrences//Selection,
* McsEngl.VscCmds.Ctrl+Shift+L: Select All Occurrences//Selection,

Selection/Duplicate Selection
* McsEngl.VscCmd.Selection/Duplicate Selection,
* McsEngl.VscCmd.Duplicate Selection//Selection,

Selection/Add Previous Occurrence
* McsEngl.VscCmd.Selection/Add Previous Occurrence,
* McsEngl.VscCmd.Add Previous Occurrence//Selection,

Selection/Switch to Ctrl+Click for Multi-Cursor
* McsEngl.VscCmd.Selection/Switch to Ctrl+Click for Multi-Cursor,
* McsEngl.VscCmd.Switch to Ctrl+Click for Multi-Cursor//Selection,

Selection/Column Selection Mode
* McsEngl.VscCmd.Selection/Column Selection Mode,
* McsEngl.VscCmd.Column Selection Mode//Selection,

VscCmd.menu.view

description::
× HitpMcs-creation: {2026-03-26},
* Command Palette... Ctrl+Shift+P
* Open View...
*
* Appearance
* Editor Layout
*
* Explorer Ctrl+Shift+E
* Search Ctrl+Shift+F
* Source Control Ctrl+Shift+G
* Run Ctrl+Shift+D
* Extensions Ctrl+Shift+X
* Testing
*
* Chat Ctrl+Alt+I
*
* Problems Ctrl+Shift+M
* Output Ctrl+Shift+U
* Debug Console Ctrl+Shift+Y
* Terminal Ctrl+`
*
* Word Wrap Alt+Z

name:::
* McsEngl.VscCmd.view-menu,

View/Command Palette...: Ctrl+Shift+P
· From here, you have access to all functionality within VS Code, including keyboard shortcuts for the most common operations.
· The Command Palette supports different modes of operation:
1) Command mode (>): after the > symbol, start typing to filter the command list. For example, type move terminal to find commands to move the terminal to a new window.
2) Quick Open mode: remove the > character and start typing to search for files in your workspace. You can use the Ctrl+P keyboard shortcut to open the Command Palette and start searching for files directly.
3) Symbol search mode (#): replace the > character by # to search for symbols like variables or functions in your code.
[{2026-03-26 retrieved} https://code.visualstudio.com/docs/getstarted/getting-started]

* McsEngl.VscCmd.View/Command Palette...: Ctrl+Shift+P,
* McsEngl.VscCmd.Command Palette...: Ctrl+Shift+P//View,
* McsEngl.VscCmd.Ctrl+Shift+P: Command Palette...//View,
* McsEngl.VscCmd.Palette: Ctrl+Shift+P//View,
* McsEngl.VscCmds.Ctrl+Shift+P: Command Palette...//View,

View/Explorer: Ctrl+Shift+E
* McsEngl.VscCmd.View/Explorer: Ctrl+Shift+E,
* McsEngl.VscCmd.Explorer: Ctrl+Shift+E//View,
* McsEngl.VscCmd.Ctrl+Shift+E: Explorer//View,
* McsEngl.VscCmds.Ctrl+Shift+E: Explorer//View,

View/Search: Ctrl+Shift+F
* McsEngl.VscCmd.View/Search: Ctrl+Shift+F,
* McsEngl.VscCmd.Search: Ctrl+Shift+F//View,
* McsEngl.VscCmd.Ctrl+Shift+F: Search//View,
* McsEngl.VscCmds.Ctrl+Shift+F: Search//View,

View/Source Control: Ctrl+Shift+G
* McsEngl.VscCmd.View/Source Control: Ctrl+Shift+G,
* McsEngl.VscCmd.Source Control: Ctrl+Shift+G//View,
* McsEngl.VscCmd.Ctrl+Shift+G: Source Control//View,
* McsEngl.VscCmds.Ctrl+Shift+G: Source Control//View,

View/Run: Ctrl+Shift+D
* McsEngl.VscCmd.View/Run: Ctrl+Shift+D,
* McsEngl.VscCmd.Run: Ctrl+Shift+D//View,
* McsEngl.VscCmd.Ctrl+Shift+D: Run//View,
* McsEngl.VscCmds.Ctrl+Shift+D: Run//View,

View/Extensions: Ctrl+Shift+X (link)

View/Chat: Ctrl+Alt+I (link)

View/Problems: Ctrl+Shift+M
* McsEngl.VscCmd.View/Problems: Ctrl+Shift+M,
* McsEngl.VscCmd.Problems: Ctrl+Shift+M//View,
* McsEngl.VscCmd.Ctrl+Shift+M: Problems//View,
* McsEngl.VscCmds.Ctrl+Shift+M: Problems//View,

View/Output: Ctrl+Shift+U
* McsEngl.VscCmd.View/Output: Ctrl+Shift+U,
* McsEngl.VscCmd.Output: Ctrl+Shift+U//View,
* McsEngl.VscCmd.Ctrl+Shift+U: Output//View,
* McsEngl.VscCmds.Ctrl+Shift+U: Output//View,

View/Debug Console: Ctrl+Shift+Y
* McsEngl.VscCmd.View/Debug Console: Ctrl+Shift+Y,
* McsEngl.VscCmd.Debug Console: Ctrl+Shift+Y//View,
* McsEngl.VscCmd.Ctrl+Shift+Y: Debug Console//View,
* McsEngl.VscCmds.Ctrl+Shift+Y: Debug Console//View,

View/Terminal: Ctrl+`
* McsEngl.VscCmd.View/Terminal: Ctrl+`,
* McsEngl.VscCmd.Terminal: Ctrl+`//View,
* McsEngl.VscCmd.Ctrl+`: Terminal//View,
* McsEngl.VscCmds.Ctrl+`: Terminal//View,

View/Word Wrap: Alt+Z
* McsEngl.VscCmd.View/Word Wrap: Alt+Z,
* McsEngl.VscCmd.Word Wrap: Alt+Z//View,
* McsEngl.VscCmd.Alt+Z: Word Wrap//View,
* McsEngl.VscCmds.Alt+Z: Word Wrap//View,

View/Open View...
* McsEngl.VscCmd.View/Open View...,
* McsEngl.VscCmd.Open View...//View,

View/Appearance
* McsEngl.VscCmd.View/Appearance,
* McsEngl.VscCmd.Appearance//View,

View/Editor Layout
* McsEngl.VscCmd.View/Editor Layout,
* McsEngl.VscCmd.Editor Layout//View,

View/Testing
* McsEngl.VscCmd.View/Testing,
* McsEngl.VscCmd.Testing//View,

VscCmd.menu.go

description::
× HitpMcs-creation: {2026-03-26},
* Back Alt+LeftArrow
* Forward Alt+RightArrow
* Last Edit Location Ctrl+K Ctrl+Q
*
* Switch Editor
* Switch Group
*
* Go to File... Ctrl+P
* Go to Symbol in Workspace... Ctrl+T
*
* Go to Symbol in Editor... Ctrl+Shift+O
* Go to Definition F12
* Go to Declaration
* Go to Type Definition
* Go to Implementations Ctrl+F12
* Go to References Shift+F12
*
* Go to Line/Column... Ctrl+G
* Go to Bracket Ctrl+Shift+\
*
* Next Problem F8
* Previous Problem Shift+F8

name:::
* McsEngl.VscCmd.go-menu,

Go/Back: Alt+LeftArrow
* McsEngl.VscCmd.Go/Back: Alt+LeftArrow,
* McsEngl.VscCmd.Back: Alt+LeftArrow//Go,
* McsEngl.VscCmd.Alt+LeftArrow: Back//Go,
* McsEngl.VscCmds.Alt+LeftArrow: Back//Go,

Go/Forward: Alt+RightArrow
* McsEngl.VscCmd.Go/Forward: Alt+RightArrow,
* McsEngl.VscCmd.Forward: Alt+RightArrow//Go,
* McsEngl.VscCmd.Alt+RightArrow: Forward//Go,
* McsEngl.VscCmds.Alt+RightArrow: Forward//Go,

Go/Last Edit Location: Ctrl+K Ctrl+Q
* McsEngl.VscCmd.Go/Last Edit Location: Ctrl+K Ctrl+Q,
* McsEngl.VscCmd.Last Edit Location: Ctrl+K Ctrl+Q//Go,
* McsEngl.VscCmd.Ctrl+K Ctrl+Q: Last Edit Location//Go,
* McsEngl.VscCmds.Ctrl+K Ctrl+Q: Last Edit Location//Go,

Go/Go to File...: Ctrl+P
* McsEngl.VscCmd.Go/Go to File...: Ctrl+P,
* McsEngl.VscCmd.Go to File...: Ctrl+P//Go,
* McsEngl.VscCmd.Ctrl+P: Go to File...//Go,
* McsEngl.VscCmds.Ctrl+P: Go to File...//Go,

Go/Go to Symbol in Workspace...: Ctrl+T
* McsEngl.VscCmd.Go/Go to Symbol in Workspace...: Ctrl+T,
* McsEngl.VscCmd.Go to Symbol in Workspace...: Ctrl+T//Go,
* McsEngl.VscCmd.Ctrl+T: Go to Symbol in Workspace...//Go,
* McsEngl.VscCmds.Ctrl+T: Go to Symbol in Workspace...//Go,

Go/Go to Symbol in Editor...: Ctrl+Shift+O
* McsEngl.VscCmd.Go/Go to Symbol in Editor...: Ctrl+Shift+O,
* McsEngl.VscCmd.Go to Symbol in Editor...: Ctrl+Shift+O//Go,
* McsEngl.VscCmd.Ctrl+Shift+O: Go to Symbol in Editor...//Go,
* McsEngl.VscCmds.Ctrl+Shift+O: Go to Symbol in Editor...//Go,

Go/Go to Definition: F12
* McsEngl.VscCmd.Go/Go to Definition: F12,
* McsEngl.VscCmd.Go to Definition: F12//Go,
* McsEngl.VscCmd.F12: Go to Definition//Go,
* McsEngl.VscCmds.F12: Go to Definition//Go,

Go/Go to Implementations: Ctrl+F12
* McsEngl.VscCmd.Go/Go to Implementations: Ctrl+F12,
* McsEngl.VscCmd.Go to Implementations: Ctrl+F12//Go,
* McsEngl.VscCmd.Ctrl+F12: Go to Implementations//Go,
* McsEngl.VscCmds.Ctrl+F12: Go to Implementations//Go,

Go/Go to References: Shift+F12
* McsEngl.VscCmd.Go/Go to References: Shift+F12,
* McsEngl.VscCmd.Go to References: Shift+F12//Go,
* McsEngl.VscCmd.Shift+F12: Go to References//Go,
* McsEngl.VscCmds.Shift+F12: Go to References//Go,

Go/Go to Line/Column...: Ctrl+G
* McsEngl.VscCmd.Go/Go to Line/Column...: Ctrl+G,
* McsEngl.VscCmd.Go to Line/Column...: Ctrl+G//Go,
* McsEngl.VscCmd.Ctrl+G: Go to Line/Column...//Go,
* McsEngl.VscCmds.Ctrl+G: Go to Line/Column...//Go,

Go/Go to Bracket: Ctrl+Shift+\
* McsEngl.VscCmd.Go/Go to Bracket: Ctrl+Shift+\,
* McsEngl.VscCmd.Go to Bracket: Ctrl+Shift+\//Go,
* McsEngl.VscCmd.Ctrl+Shift+\: Go to Bracket//Go,
* McsEngl.VscCmds.Ctrl+Shift+\: Go to Bracket//Go,

Go/Next Problem: F8
* McsEngl.VscCmd.Go/Next Problem: F8,
* McsEngl.VscCmd.Next Problem: F8//Go,
* McsEngl.VscCmd.F8: Next Problem//Go,
* McsEngl.VscCmds.F8: Next Problem//Go,

Go/Previous Problem: Shift+F8
* McsEngl.VscCmd.Go/Previous Problem: Shift+F8,
* McsEngl.VscCmd.Previous Problem: Shift+F8//Go,
* McsEngl.VscCmd.Shift+F8: Previous Problem//Go,
* McsEngl.VscCmds.Shift+F8: Previous Problem//Go,

Go/Next Change: Alt+F3
* McsEngl.VscCmd.Go/Next Change: Alt+F3,
* McsEngl.VscCmd.Next Change: Alt+F3//Go,
* McsEngl.VscCmd.Alt+F3: Next Change//Go,
* McsEngl.VscCmds.Alt+F3: Next Change//Go,

Go/Previous Change: Shift+Alt+F3
* McsEngl.VscCmd.Go/Previous Change: Shift+Alt+F3,
* McsEngl.VscCmd.Previous Change: Shift+Alt+F3//Go,
* McsEngl.VscCmd.Shift+Alt+F3: Previous Change//Go,
* McsEngl.VscCmds.Shift+Alt+F3: Previous Change//Go,

Go/Switch Editor
* McsEngl.VscCmd.Go/Switch Editor,
* McsEngl.VscCmd.Switch Editor//Go,

Go/Switch Group
* McsEngl.VscCmd.Go/Switch Group,
* McsEngl.VscCmd.Switch Group//Go,

Go/Go to Declaration
* McsEngl.VscCmd.Go/Go to Declaration,
* McsEngl.VscCmd.Go to Declaration//Go,

Go/Go to Type Definition
* McsEngl.VscCmd.Go/Go to Type Definition,
* McsEngl.VscCmd.Go to Type Definition//Go,

VscCmd.menu.run

description::
× HitpMcs-creation: {2026-03-26},
* Start Debugging F5
* Run Without Debugging Ctrl+F5
* Stop Debugging Shift+F5
* Restart Debugging Ctrl+Shift+F5
*
* Open Configurations
* Add Configuration...
*
* Step Over F10
* Step Into F11
* Step Out Shift+F11
* Continue F5
*
* Toggle Breakpoint F9
* New Breakpoint
*
* Enable All Breakpoints
* Disable All Breakpoints
* Remove All Breakpoints
*
* Install Additional Debuggers...

name:::
* McsEngl.VscCmd.run-menu,

Run/Start Debugging: F5
* McsEngl.VscCmd.Run/Start Debugging: F5,
* McsEngl.VscCmd.Start Debugging: F5//Run,
* McsEngl.VscCmd.F5: Start Debugging//Run,
* McsEngl.VscCmds.F5: Start Debugging//Run,

Run/Run Without Debugging: Ctrl+F5
* McsEngl.VscCmd.Run/Run Without Debugging: Ctrl+F5,
* McsEngl.VscCmd.Run Without Debugging: Ctrl+F5//Run,
* McsEngl.VscCmd.Ctrl+F5: Run Without Debugging//Run,
* McsEngl.VscCmds.Ctrl+F5: Run Without Debugging//Run,

Run/Stop Debugging: Shift+F5
* McsEngl.VscCmd.Run/Stop Debugging: Shift+F5,
* McsEngl.VscCmd.Stop Debugging: Shift+F5//Run,
* McsEngl.VscCmd.Shift+F5: Stop Debugging//Run,
* McsEngl.VscCmds.Shift+F5: Stop Debugging//Run,

Run/Restart Debugging: Ctrl+Shift+F5
* McsEngl.VscCmd.Run/Restart Debugging: Ctrl+Shift+F5,
* McsEngl.VscCmd.Restart Debugging: Ctrl+Shift+F5//Run,
* McsEngl.VscCmd.Ctrl+Shift+F5: Restart Debugging//Run,
* McsEngl.VscCmds.Ctrl+Shift+F5: Restart Debugging//Run,

Run/Step Over: F10
* McsEngl.VscCmd.Run/Step Over: F10,
* McsEngl.VscCmd.Step Over: F10//Run,
* McsEngl.VscCmd.F10: Step Over//Run,
* McsEngl.VscCmds.F10: Step Over//Run,

Run/Step Into: F11
* McsEngl.VscCmd.Run/Step Into: F11,
* McsEngl.VscCmd.Step Into: F11//Run,
* McsEngl.VscCmd.F11: Step Into//Run,
* McsEngl.VscCmds.F11: Step Into//Run,

Run/Step Out: Shift+F11
* McsEngl.VscCmd.Run/Step Out: Shift+F11,
* McsEngl.VscCmd.Step Out: Shift+F11//Run,
* McsEngl.VscCmd.Shift+F11: Step Out//Run,
* McsEngl.VscCmds.Shift+F11: Step Out//Run,

Run/Continue: F5
* McsEngl.VscCmd.Run/Continue: F5,
* McsEngl.VscCmd.Continue: F5//Run,
* McsEngl.VscCmd.F5: Continue//Run,
* McsEngl.VscCmds.F5: Continue//Run,

Run/Toggle Breakpoint: F9
* McsEngl.VscCmd.Run/Toggle Breakpoint: F9,
* McsEngl.VscCmd.Toggle Breakpoint: F9//Run,
* McsEngl.VscCmd.F9: Toggle Breakpoint//Run,
* McsEngl.VscCmds.F9: Toggle Breakpoint//Run,

Run/Open Configurations
* McsEngl.VscCmd.Run/Open Configurations,
* McsEngl.VscCmd.Open Configurations//Run,

Run/Add Configuration...
* McsEngl.VscCmd.Run/Add Configuration...,
* McsEngl.VscCmd.Add Configuration...//Run,

Run/New Breakpoint
* McsEngl.VscCmd.Run/New Breakpoint,
* McsEngl.VscCmd.New Breakpoint//Run,

Run/Enable All Breakpoints
* McsEngl.VscCmd.Run/Enable All Breakpoints,
* McsEngl.VscCmd.Enable All Breakpoints//Run,

Run/Disable All Breakpoints
* McsEngl.VscCmd.Run/Disable All Breakpoints,
* McsEngl.VscCmd.Disable All Breakpoints//Run,

Run/Remove All Breakpoints
* McsEngl.VscCmd.Run/Remove All Breakpoints,
* McsEngl.VscCmd.Remove All Breakpoints//Run,

Run/Install Additional Debuggers...
* McsEngl.VscCmd.Run/Install Additional Debuggers...,
* McsEngl.VscCmd.Install Additional Debuggers...//Run,

VscCmd.menu.terminal

description::
× HitpMcs-creation: {2026-03-26},
* New Terminal Ctrl+Shift+`
* Split Terminal Ctrl+Shift+5
* New Terminal Window Ctrl+Shift+Alt+`
*
* Run Task...
* Run Build Task... Ctrl+Shift+B
* Run Active File
* Run Selected Text
*
* Show Running Tasks...
* Restart Running Task...
* Terminate Task...
*
* Configure Tasks...
* Configure Default Build Task...

name:::
* McsEngl.VscCmd.terminal-menu,

Terminal/New Terminal: Ctrl+Shift+`
* McsEngl.VscCmd.Terminal/New Terminal: Ctrl+Shift+`,
* McsEngl.VscCmd.New Terminal: Ctrl+Shift+`//Terminal,
* McsEngl.VscCmd.Ctrl+Shift+`: New Terminal//Terminal,
* McsEngl.VscCmds.Ctrl+Shift+`: New Terminal//Terminal,

Terminal/Split Terminal: Ctrl+Shift+5
* McsEngl.VscCmd.Terminal/Split Terminal: Ctrl+Shift+5,
* McsEngl.VscCmd.Split Terminal: Ctrl+Shift+5//Terminal,
* McsEngl.VscCmd.Ctrl+Shift+5: Split Terminal//Terminal,
* McsEngl.VscCmds.Ctrl+Shift+5: Split Terminal//Terminal,

Terminal/New Terminal Window: Ctrl+Shift+Alt+`
* McsEngl.VscCmd.Terminal/New Terminal Window: Ctrl+Shift+Alt+`,
* McsEngl.VscCmd.New Terminal Window: Ctrl+Shift+Alt+`//Terminal,
* McsEngl.VscCmd.Ctrl+Shift+Alt+`: New Terminal Window//Terminal,
* McsEngl.VscCmds.Ctrl+Shift+Alt+`: New Terminal Window//Terminal,

Terminal/Run Build Task...: Ctrl+Shift+B
* McsEngl.VscCmd.Terminal/Run Build Task...: Ctrl+Shift+B,
* McsEngl.VscCmd.Run Build Task...: Ctrl+Shift+B//Terminal,
* McsEngl.VscCmd.Ctrl+Shift+B: Run Build Task...//Terminal,
* McsEngl.VscCmds.Ctrl+Shift+B: Run Build Task...//Terminal,

Terminal/Run Task...
* McsEngl.VscCmd.Terminal/Run Task...,
* McsEngl.VscCmd.Run Task...//Terminal,

Terminal/Run Active File
* McsEngl.VscCmd.Terminal/Run Active File,
* McsEngl.VscCmd.Run Active File//Terminal,

Terminal/Run Selected Text
* McsEngl.VscCmd.Terminal/Run Selected Text,
* McsEngl.VscCmd.Run Selected Text//Terminal,

Terminal/Show Running Tasks...
* McsEngl.VscCmd.Terminal/Show Running Tasks...,
* McsEngl.VscCmd.Show Running Tasks...//Terminal,

Terminal/Restart Running Task...
* McsEngl.VscCmd.Terminal/Restart Running Task...,
* McsEngl.VscCmd.Restart Running Task...//Terminal,

Terminal/Terminate Task...
* McsEngl.VscCmd.Terminal/Terminate Task...,
* McsEngl.VscCmd.Terminate Task...//Terminal,

Terminal/Configure Tasks...
* McsEngl.VscCmd.Terminal/Configure Tasks...,
* McsEngl.VscCmd.Configure Tasks...//Terminal,

Terminal/Configure Default Build Task...
* McsEngl.VscCmd.Terminal/Configure Default Build Task...,
* McsEngl.VscCmd.Configure Default Build Task...//Terminal,

VscCmd.menu.help

description::
× HitpMcs-creation: {2026-03-26},
* Welcome
*
* Show All Commands Ctrl+Shift+P
* Documentation
* Editor Playground
* Open Walkthrough...
* Show Release Notes
* Get Started with Accessibility Features
* Ask @vscode
*
* Keyboard Shortcuts Reference Ctrl+K Ctrl+R
* Video Tutorials
* Tips and Tricks
*
* Join Us on YouTube
* Search Feature Requests
* Report Issue
*
* View License
* Privacy Statement
*
* Toggle Developer Tools

name:::
* McsEngl.VscCmd.help-menu,

Help/Show All Commands: Ctrl+Shift+P
* McsEngl.VscCmd.Help/Show All Commands: Ctrl+Shift+P,
* McsEngl.VscCmd.Show All Commands: Ctrl+Shift+P//Help,
* McsEngl.VscCmd.Ctrl+Shift+P: Show All Commands//Help,
* McsEngl.VscCmds.Ctrl+Shift+P: Show All Commands//Help,

Help/Keyboard Shortcuts Reference: Ctrl+K Ctrl+R
· https://code.visualstudio.com/shortcuts/keyboard-shortcuts-windows.pdf,

* McsEngl.VscCmd.Help/Keyboard Shortcuts Reference: Ctrl+K Ctrl+R,
* McsEngl.VscCmd.Keyboard Shortcuts Reference: Ctrl+K Ctrl+R//Help,
* McsEngl.VscCmd.Ctrl+K Ctrl+R: Keyboard Shortcuts Reference//Help,
* McsEngl.VscCmds.Ctrl+K Ctrl+R: Keyboard Shortcuts Reference//Help,

Help/Welcome
* McsEngl.VscCmd.Help/Welcome,
* McsEngl.VscCmd.Welcome//Help,

Help/Documentation
* McsEngl.VscCmd.Help/Documentation,
* McsEngl.VscCmd.Documentation//Help,

Help/Editor Playground
* McsEngl.VscCmd.Help/Editor Playground,
* McsEngl.VscCmd.Editor Playground//Help,

Help/Open Walkthrough...
* McsEngl.VscCmd.Help/Open Walkthrough...,
* McsEngl.VscCmd.Open Walkthrough...//Help,

Help/Show Release Notes
* McsEngl.VscCmd.Help/Show Release Notes,
* McsEngl.VscCmd.Show Release Notes//Help,

Help/Get Started with Accessibility Features
* McsEngl.VscCmd.Help/Get Started with Accessibility Features,
* McsEngl.VscCmd.Get Started with Accessibility Features//Help,

Help/Ask @vscode
* McsEngl.VscCmd.Help/Ask @vscode,
* McsEngl.VscCmd.Ask @vscode//Help,

Help/Video Tutorials
* McsEngl.VscCmd.Help/Video Tutorials,
* McsEngl.VscCmd.Video Tutorials//Help,

Help/Tips and Tricks
* McsEngl.VscCmd.Help/Tips and Tricks,
* McsEngl.VscCmd.Tips and Tricks//Help,

Help/Join Us on YouTube
* McsEngl.VscCmd.Help/Join Us on YouTube,
* McsEngl.VscCmd.Join Us on YouTube//Help,

Help/Search Feature Requests
* McsEngl.VscCmd.Help/Search Feature Requests,
* McsEngl.VscCmd.Search Feature Requests//Help,

Help/Report Issue
* McsEngl.VscCmd.Help/Report Issue,
* McsEngl.VscCmd.Report Issue//Help,

Help/View License
* McsEngl.VscCmd.Help/View License,
* McsEngl.VscCmd.View License//Help,

Help/Privacy Statement
* McsEngl.VscCmd.Help/Privacy Statement,
* McsEngl.VscCmd.Privacy Statement//Help,

Help/Toggle Developer Tools
* McsEngl.VscCmd.Help/Toggle Developer Tools,
* McsEngl.VscCmd.Toggle Developer Tools//Help,

Help/Open Process Explorer
* McsEngl.VscCmd.Help/Open Process Explorer,
* McsEngl.VscCmd.Open Process Explorer//Help,

Help/Check for Updates
* McsEngl.VscCmd.Help/Check for Updates,
* McsEngl.VscCmd.Check for Updates//Help,

Help/About
* McsEngl.VscCmd.Help/About,
* McsEngl.VscCmd.About//Help,

VscCmd.internal

description::
× HitpMcs-creation: {2026-03-28},
"Visual Studio Code relies on a robust "Command" system. Every action you take—from saving a file to splitting the editor—is mapped to an internal command ID (e.g., `workbench.action.files.save`).
Here is how to access, use, and identify these internal commands.
---
## 1. How to Find Any Command ID
If you want to use a command in a script, keybinding, or extension, you first need its internal ID.
* **Keyboard Shortcuts Editor:** Press `Ctrl+K Ctrl+S` (Windows/Linux) or `Cmd+K Cmd+S` (Mac). Right-click any command and select **Copy Command ID**.
* **Default Keybindings JSON:** To see the "master list" including those without shortcuts, open the Command Palette and run: `Preferences: Open Default Keyboard Shortcuts (JSON)`.
* **Developer Tools:** If you want to see what command is triggered when you click a button, open the Developer Tools (`Help > Toggle Developer Tools`) and watch the Console/Network tab (though this is more for core contributors).
---
## 2. Common Internal Command Categories
Most internal commands follow a specific naming convention based on their scope:
### Editor Actions (`editor.action.*`)
These control the text within the active window.
| Command ID | Action |
| `editor.action.formatDocument` | Formats the current file. |
| `editor.action.commentLine` | Toggles a line comment. |
| `editor.action.rename` | Triggers "Rename Symbol" (F2). |
| `editor.action.clipboardCopyAction` | Standard copy to clipboard. |
### Workbench Actions (`workbench.action.*`)
These control the UI, layout, and global features.
| Command ID | Action |
| `workbench.action.files.save` | Saves the current file. |
| `workbench.action.terminal.toggleTerminal` | Shows/hides the integrated terminal. |
| `workbench.action.splitEditor` | Splits the editor into two groups. |
| `workbench.action.reloadWindow` | Restarts the VS Code UI. |
---
## 3. Advanced Navigation Prefixes
The **Command Palette** (`Ctrl+Shift+P`) is actually a multi-tool. You can change what it searches for by using these internal prefixes:
| Prefix | Mode | Description |
| `>` | **Command Mode** | Run any VS Code or Extension command. |
| `@` | **Symbol Search** | Find variables, functions, or classes in the *current* file. |
| `#` | **Workspace Symbol** | Search for symbols across the *entire* project. |
| `:` | **Go to Line** | Type a number to jump to that line. |
| `?` | **Help** | Displays all available palette prefixes. |
---
## 4. Running Commands Programmatically
If you are building an extension or a task, you can trigger these commands using the API:
javascript
// Example: Saving all files via the API
vscode.commands.executeCommand('workbench.action.files.saveAll');

**Note on "Internal" Commands:** Commands starting with an underscore (e.g., `_executeCodeActionProvider`) are considered private APIs. They often require specific arguments and are subject to change, so use them with caution.
---
**Would you like me to show you how to map one of these internal commands to a custom keybinding in your `keybindings.json`?**"
[{2026-03-28 retrieved} https://gemini.google.com/app/6f96f2c0c2da5f3c]

name:::
* McsEngl.VscCmd.internal,

VscCmd.shell

description::
× HitpMcs-creation: {2026-03-28},
"Here's a comprehensive guide to VS Code shell commands:
## Installing VS Code Shell Commands
If you want to use `code` command in terminal:
### macOS
- Open VS Code
- Open Command Palette (`Cmd+Shift+P`)
- Type "Shell Command: Install 'code' command in PATH"
- Click to install
### Windows
- During installation, check "Add to PATH" option
- Or manually add VS Code's `bin` folder to PATH
### Linux
- Usually installed automatically with package managers
- Or create symlink: `sudo ln -s /path/to/vscode/bin/code /usr/local/bin/code`
## Basic Shell Commands
bash
# Open current directory in VS Code
code .
# Open specific file
code filename.txt
# Open specific folder
code /path/to/folder
# Open multiple files
code file1.txt file2.txt
# Open in new window
code -n
# Open in existing window (reuse current)
code -r
# Compare two files (diff)
code --diff file1.txt file2.txt
# Open with specific line and column
code -g file.txt:10:5

## Useful Command Line Options
bash
# List all options
code --help
# Disable extensions temporarily
code --disable-extensions
# Open with specific profile
code --profile "Profile Name"
# Open in safe mode (extensions disabled)
code --safe
# Wait for files to close before returning
code --wait
# Show verbose output
code --verbose

## Git Integration
bash
# Use VS Code as git editor
git config --global core.editor "code --wait"
# Use VS Code as git diff tool
git config --global diff.tool vscode
git config --global difftool.vscode.cmd 'code --wait --diff $LOCAL $REMOTE'
# View git diff in VS Code
git difftool

## Aliases (Optional)
Add to `~/.bashrc`, `~/.zshrc`, or `~/.config/fish/config.fish`:
bash
# Common aliases
alias c="code"
alias c.="code ."
alias cn="code -n"
alias cdiff="code --diff"

## Platform-Specific Notes
### Windows (PowerShell/Cmd)
powershell
# Similar commands work
code .
code file.txt
# Using with PowerShell
code . -r # Reuse window

### WSL (Windows Subsystem for Linux)
bash
# Install VS Code server in WSL
code .
# This automatically installs required components

## Troubleshooting
If `code` command isn't recognized:
1. Restart terminal after installation
2. Check PATH: `echo $PATH` (macOS/Linux) or `echo %PATH%` (Windows)
3. Reinstall shell command from VS Code Command Palette
Would you like more details about any specific shell command or scenario?"
[{2026-03-28 retrieved} https://chat.deepseek.com/a/chat/s/277c551d-1afc-4198-bdba-a4d64e405db8]

name:::
* McsEngl.VscCmd.shell,

VscCmd.jEdit

description::
× HitpMcs-creation: {2026-03-30},
· jEdit commands in macro to VSCode:

* textArea.delete(); "deleteRight",
* textArea.goToEndOfLine(false); "cursorEnd"
* textArea.goToEndOfLine(true); "cursorEndSelect"
* textArea.goToEndOfWhiteSpace(false); "cursorLineEnd",
* textArea.goToNextWord(true,false); "cursorWordStartRight",
* textArea.goToPrevLine(false); "cursorUp",
* textArea.goToStartOfLine(false); "cursorHome",
* textArea.goToStartOfWhiteSpace(false); "cursorHome",
* textArea.insertEnterAndIndent(); "editor.action.insertLineAfter",
* textArea.setSelectedText("xxx"); {"command": "type", "args": {"text": "xxx"}},

name:::
* McsEngl.VscCmd.jEdit,

VscCmd.shortcut

description::
× HitpMcs-creation: {2026-04-04},
× https://code.visualstudio.com/docs/configure/keybindings,
· command in shortcut format.

name:::
* McsEngl.VscCmd.shortcut!⇒VscCmds,
* McsEngl.VscCmds!=VscCmd.shortcut,
* McsEngl.Vscode'keyboard-shortcut,
* McsEngl.Vscode'shortcut,

Previous-Match: shift+enter::
* McsEngl.VscCmd.Find-Previous: shift+enter,
* McsEngl.VscCmd.Previous-Match: shift+enter,
* McsEngl.VscCmd.shift+enter: Previous-Match,
* McsEngl.VscCmds.shift+enter: Previous-Match,

Next-Match: enter::
* McsEngl.VscCmd.Find-Next: enter,
* McsEngl.VscCmd.Next-Match: enter,
* McsEngl.VscCmd.enter: Next-Match,
* McsEngl.VscCmds.enter: Next-Match,

keyboard-rule of VscCmds

description::
× HitpMcs-creation: {2026-04-15},
× https://code.visualstudio.com/docs/configure/keybindings#_keyboard-rules,
× https://code.visualstudio.com/api/references/when-clause-contexts,
"A keyboard shortcut configuration in VS Code is also known as a keyboard rule. Each rule consists of the following attributes:
* key: describes the pressed key(s), for example Ctrl+F.
* command: the identifier of the VS Code command to execute, for example workbench.view.explorer to open the Explorer view.
* when: (optional) clause containing a boolean expression that is evaluated depending on the current context."
[{2026-04-15 retrieved} https://code.visualstudio.com/docs/configure/keybindings#_keyboard-rules]

name::
* McsEngl.VscCmds'keyboard-rule,
* McsEngl.Vscode'keyboard-rule,

keyboard-shortcut-editor of VscCmds

description::
× HitpMcs-creation: {2026-04-15},
· In the Keyboard Shortcuts editor, you can filter on specific keystrokes to see which commands are bound to which keys.
[{2026-04-15 retrieved} https://code.visualstudio.com/docs/configure/keybindings#_how-can-i-find-out-what-command-is-bound-to-a-specific-key]
× %APPDATA%\Code\User\keybindings.json
× Keyboard Shortcuts editor,
· You can customize these default shortcuts or add new ones for your favorite commands and actions by using the Keyboard Shortcuts editor (Ctrl+K Ctrl+S).

name::
* McsEngl.VscCmd.File/Preferences/Keyboard Shortcuts: Ctrl+K Ctrl+S,
* McsEngl.VscCmd.Keyboard Shortcuts: Ctrl+K Ctrl+S//Preferences//File,
* McsEngl.VscCmd.Preferences: Open Keyboard Shortcuts (palette),
* McsEngl.VscCmds'keyboard-shortcuts-editor,
* McsEngl.Vscode'keyboard-shortcuts-editor,

keybindings.json of VscCmds

description::
× HitpMcs-creation: {2026-04-15},

How to add a keyboard shortcut to an action, for example, add Ctrl+D to Delete Lines
Find a rule that triggers the action in the Default Keyboard Shortcuts and write a modified version of it in your keybindings.json file:
// Original, in Default Keyboard Shortcuts
{ "key": "ctrl+shift+k", "command": "editor.action.deleteLines", "when": "editorTextFocus" },
// Modified, in User/keybindings.json, Ctrl+D now will also trigger this action
{ "key": "ctrl+d", "command": "editor.action.deleteLines", "when": "editorTextFocus" },

name::
* McsEngl.VscCmd.Preferences: Open Keyboard Shortcuts (JSON),
* McsEngl.VscCmds'keybindings.json,
* McsEngl.Vscode'keybindings.json,

VscCmd.custom

description::
× HitpMcs-creation: {2026-04-02},
· MY custom-commands.
· to create custom-commands I use:
1) custom-extensions, for complex tasks,
2) keybindings.json commands.
· I am using the-shortcuts ctrl+alt+...

=== SYMBOL:
* ctrl+alt+-, // selected-number dicrease
* ctrl+alt+=, // selected-number increase

=== CHAR:
* ctrl+alt+c h l, // char Html LeshThan: & lt;
* ctrl+alt+c h s, // char Html space: & nbsp;
* ctrl+alt+c i, // char isert from Integer EXTENSION
* ctrl+alt+c p b, // char hitP insert line Break: " <br> "
* ctrl+alt+c p e, // char hitP name Equal: !=
* ctrl+alt+c p m, // char hitP name Main: !⇒
* ctrl+alt+c p s, // char hitP sentence: " <br>· "

=== HTML
* ctrl+alt+h b // Html Bold
* ctrl+alt+h c d // Html CoDe: <code>
* ctrl+alt+h c m // Html CoMment: <!-- -->
* ctrl+alt+h l i, // Html Link Insert
* ctrl+alt+h l s, // Html Link Selection
* ctrl+alt+h t // Html Tag insert EXTENSION

=== MACRO
* ctrl+alt+m c, // macro Copy recording
* ctrl+alt+m d, // macro insert date: {2026-03-30}
* ctrl+alt+m escape, // macro stop playback
* ctrl+alt+m p, // macro Cancel recording
* ctrl+alt+m p, // macro Playback
* ctrl+alt+m r, // macro recording
* ctrl+alt+m r, // macro stop recording

=== HITP:
=== HITP COLOR:
* ctrl+alt+p c b, // hitP Color Blue
* ctrl+alt+p c g, // hitP Color Green
* ctrl+alt+p c r, // hitP Color Red
=== HITP FORMAT:
* ctrl+alt+p f u, // hitP Format Underline
=== HITP ELEMENT:
* ctrl+alt+p e a, // hitP Element Audio
* ctrl+alt+p h =, // hitP Heading Increase
* ctrl+alt+p h -, // hitP Heading Decrease
=== HITP LINK:
* ctrl+alt+p l i, // hitP Linkpreview Insert
* ctrl+alt+p l s, // hitP Linkpreview Selection
=== HITP NAME:
* ctrl+alt+p n a l, // hitP name ALbanian
* ctrl+alt+p n a r, // hitP name ARabic
* ctrl+alt+p n c, // hitP name Chinese
* ctrl+alt+p n e, // hitP name Esperanto
* ctrl+alt+p n f, // hitP name Frence
* ctrl+alt+p n g a, // hitP name GreekAncient
* ctrl+alt+p n g k, // hitP name GreeK
* ctrl+alt+p n g r, // hitP name GeRman
* ctrl+alt+p n h, // hitP name Hindi
* ctrl+alt+p n i, // hitP name Italian
* ctrl+alt+p n j, // hitP name Japanese
* ctrl+alt+p n k h, // hitP name KHmer
* ctrl+alt+p n k r, // hitP name KoRean
* ctrl+alt+p n r, // hitP name Romanean
* ctrl+alt+p n s b, // Bosnian-Croatian-Montenegrin-Serbian
* ctrl+alt+p n s l, // hitP name SlavoBuLgarian
* ctrl+alt+p n s m, // hitP name SlavoMacedonian
* ctrl+alt+p n s n, // hitP name SiNagu
* ctrl+alt+p n s p, // hitP name SPanish
* ctrl+alt+p n s r, // hitP name SlavoRussian
* ctrl+alt+p n s s, // hitP name SlavoSlovenian
* ctrl+alt+p n t, // hitP name Turkish
* ctrl+alt+p n v, // hitP name Vietnamese
=== HITP PARAGRAPH:
* ctrl+alt+p p d, // hitP Paragraph Description
* ctrl+alt+p p n, // hitP Paragraph Name
* ctrl+alt+p p p, // hitP Paragraph Description and Name
=== HITP RESOURCE:
* ctrl+alt+p r r, // hitP insert Resource Resource
* ctrl+alt+p r s, // hitP insert Resource hmnSngu
=== HITP SYNTAX:
* ctrl+alt+p s a, // hitP argument-syntax
* ctrl+alt+p s c, // hitP cause-syntax
* ctrl+alt+p s d, // hitP direction-syntax
* ctrl+alt+p s f, // hitP frequency-syntax
* ctrl+alt+p s k, // hitP subject-complement-syntax
* ctrl+alt+p s l e, // hitP syntax language Elln-Greek
* ctrl+alt+p s m, // hitP manner-syntax
* ctrl+alt+p s o, // hitP object-syntax
* ctrl+alt+p s p, // hitP sPace-syntax
* ctrl+alt+p s q, // hitP quantity-syntax
* ctrl+alt+p s s, // hitP subject-syntax
* ctrl+alt+p s t, // hitP time-syntax
* ctrl+alt+p s u, // hitP oUtput-syntax
* ctrl+alt+p s v, // hitP verb-syntax
=== HITP SAVE:
* ctrl+alt+p v 2, // hitP saVe 2 minor versioning

* ctrl+alt+t,
* ctrl+alt+v, // shows char codepoint in different formats
* F6, // misc macro

name:::
* McsEngl.VscCmd.custom!⇒VscCmdc,
* McsEngl.VscCmdc!=VscCmd.custom,
* McsEngl.Vscode'custom-command!⇒VscCmdc,

settings of Vscode

description::
× HitpMcs-creation: {2026-04-15},
× https://code.visualstudio.com/docs/configure/settings,
× user-settings-file: %APPDATA%\Code\User\settings.json
× workspace-settings-dir: workspace-dir\.vscode\
· VS Code provides two types of settings. USER SETTINGS apply globally to any VS Code instance, while WORKSPACE SETTINGS are stored with your project and apply only to that project. In the Settings editor, you can switch between user and workspace settings by using the corresponding tabs.
[{2026-03-27 retrieved} https://code.visualstudio.com/docs/getstarted/personalize-vscode]

name::
* McsEngl.VscCmd.File/Preferences/Settings: Ctrl+,,
* McsEngl.VscCmd.Preferences: Open User Settings: settings editor,
* McsEngl.VscCmd.Preferences: Open User Settings (JSON): settings file,
* McsEngl.VscCmd.Settings: Ctrl+,//Preferences//File,
* McsEngl.VscCmd.Ctrl+,: Settings//Preferences//File,
* McsEngl.VscCmds.Ctrl+,: Settings//Preferences//File,
* McsEngl.Vscode'settings: Ctrl+,//Preferences//File,
* McsEngl.Vscode'settings.json,

relation-to-Atom of Vscode

description::
× HitpMcs-creation: {2025-12-11},
"Below is a clear, business-style explanation of the relationship between **Atom** and **Visual Studio Code (VS Code)**, including their history, shared technology layers, and ecosystem implications.
---
## 1. High-Level Relationship
**Atom and VS Code are unrelated products built by different companies**, but they are connected indirectly because **both were built on top of the same underlying framework: Electron**.
* **Atom** was developed by **GitHub** (launched 2014).
* **VS Code** was developed by **Microsoft** (launched 2015).
* Both applications run on **Electron**, a framework originally created by GitHub to build desktop apps with web technologies.
---
## 2. Shared Foundation: Electron
Atom was the **first major application** built on the original Electron codebase (then called Atom Shell).
Microsoft later adopted Electron to build VS Code.
This creates the appearance of a relationship, but the editors themselves were developed entirely separately.
Key implications:
* Similar UI technology stack (HTML, CSS, JavaScript).
* Cross-platform behavior is consistent across both.
* Extensions in both systems often leveraged Node.js packages.
---
## 3. Development Philosophy Differences
Although they share a foundation, their **editor philosophies diverged significantly**.
### **Atom**
* Designed as a fully hackable, modular text editor.
* Deep customization through plugins and user configuration.
* Performance was sometimes criticized due to heavy customization layers.
### **VS Code**
* Focused on performance, developer productivity, and integrations.
* Strong built-in tooling for debugging, terminals, Git, and language servers.
* Opinionated but extensible marketplace.
---
## 4. Acquisition and Strategic Shift
In **2018**, Microsoft acquired **GitHub**.
After the acquisition:
* Microsoft continued investing in VS Code, not Atom.
* Atom’s development slowed.
* In **June 2022**, GitHub officially discontinued Atom and its associated packages.
Because Microsoft already owned VS Code, continuing Atom did not make strategic sense.
---
## 5. Impact on Users and Ecosystem
* **Atom is deprecated**, no longer maintained.
* Many Atom users migrated to **VS Code**, which offered better performance and a larger extension library.
* Some community-driven Atom forks (e.g., Pulsar) emerged to keep the ecosystem alive.
---
## Summary
| Aspect | Atom | VS Code |
| Origin | GitHub | Microsoft |
| Year released | 2014 | 2015 |
| Technology | Electron | Electron |
| Philosophy | Hackable editor | Fast, productivity-focused IDE-like editor |
| Status | Discontinued (2022) | Actively maintained |
**Relationship:**
Atom and VS Code share a common technical foundation (Electron), but they were developed independently and diverged in performance, adoption, and strategic relevance. Microsoft’s acquisition of GitHub ended Atom’s development in favor of VS Code.
---
If you want, I can also provide:
* A short historical timeline.
* A comparison of technical architectures.
* A migration guide from Atom packages/workflows to VS Code equivalents."
[{2025-12-10 retrieved} https://chatgpt.com/c/69399ae0-d638-8329-bd8d-c7dae3a8b52b]

name:::
* McsEngl.Vscode'relation-to-atom,

info-resource of Vscode

addressWpg::
× HitpMcs-creation: {2026-03-25},
* https://code.visualstudio.com/,
* GitHub: https://github.com/microsoft/vscode,
===
* https://stackoverflow.com/questions/tagged/visual-studio-code,

name:::
* McsEngl.Vscode'InfRsc,

DOING of Vscode

description::
*

name:::
* McsEngl.Vscode'doing,

evoluting of Vscode

name:::
* McsEngl.evoluting-of-Vscode,
* McsEngl.Vscode'evoluting,

{2026-04-09}-HitpMcs-creation::
· creation of current concept.

PARENT-CHILD-TREE of Vscode

parent-tree-of-Vscode::
* ,
* McsEngl.Vscode'parent-tree,

child-tree-of-Vscode::
* ,
* McsEngl.Vscode'child-tree,

WHOLE-PART-TREE of Vscode

whole-tree-of-Vscode::
* ,
* ... Sympan.
* McsEngl.Vscode'whole-tree,

part-tree-of-Vscode::
* ,
* McsEngl.Vscode'part-tree,

GENERIC-SPECIFIC-TREE of Vscode

generic-tree-of-Vscode::
* Electron-app,
* ... entity.
* McsEngl.Vscode'generic-tree,

specific-tree-of-Vscode::
* ,
* McsEngl.Vscode.specific-tree,

meta-info

this page was-visited times since {2026-04-09}

page-wholepath: synagonism.net / worldviewSngo / dirTchInf / Vscode

SEARCH::
· this page uses 'locator-names', names that when you find them, you find the-LOCATION of the-concept they denote.
⊛ GLOBAL-SEARCH:
· clicking on the-green-BAR of a-page you have access to the-global--locator-names of my-site.
· use the-prefix 'Vscode' for senso-concepts related to current concept 'Visual-Studio-Code'.
⊛ LOCAL-SEARCH:
· TYPE CTRL+F "McsLang.words-of-concept's-name", to go to the-LOCATION of the-concept.
· a-preview of the-description of a-global-name makes reading fast.

footer::
• author: Kaseluris.Nikos.1959
• email:
 mail
• edit on github: https://github.com/synagonism/McsWorld/blob/master/dirMcs/dirTchInf/McsTchInf000041.last.html,
• comments on Disqus,
• twitter: @synagonism,

webpage-versions::
• version.last.dynamic: McsTchInf000041.last.html,
• version.draft.creation: McsTchInf000041.0-1-0.2026-04-09.last.html,

support (link)